MC Namespace Reference

Namespaces
namespace	HepMC
namespace	HepMC3
namespace	HepMCStr
namespace	Pythia8

Classes
class	DecodedPID
	Implementation of classification functions according to PDG2022. More...
class	Loops

Functions
template<class T>
bool	isQuark (const T &p)
	PDG rule 2: Quarks and leptons are numbered consecutively starting from 1 and 11 respectively; to do this they are first ordered by family and within families by weak isospin.
template<>
bool	isQuark (const int &p)
template<>
bool	isQuark (const DecodedPID &p)
template<class T>
bool	isSMQuark (const T &p)
template<>
bool	isSMQuark (const int &p)
template<>
bool	isSMQuark (const DecodedPID &p)
template<class T>
bool	isStrange (const T &p)
template<>
bool	isStrange (const int &p)
template<class T>
bool	isCharm (const T &p)
template<>
bool	isCharm (const int &p)
template<class T>
bool	isBottom (const T &p)
template<>
bool	isBottom (const int &p)
template<class T>
bool	isTop (const T &p)
template<>
bool	isTop (const int &p)
template<class T>
bool	isLepton (const T &p)
	APID: the fourth generation leptons are leptons.
template<>
bool	isLepton (const int &p)
template<>
bool	isLepton (const DecodedPID &p)
template<class T>
bool	isSMLepton (const T &p)
	APID: the fourth generation leptons are not standard model leptons.
template<>
bool	isSMLepton (const int &p)
template<>
bool	isSMLepton (const DecodedPID &p)
template<class T>
bool	isChLepton (const T &p)
	APID: the fourth generation leptons are leptons.
template<>
bool	isChLepton (const int &p)
template<class T>
bool	isElectron (const T &p)
template<>
bool	isElectron (const int &p)
template<class T>
bool	isMuon (const T &p)
template<>
bool	isMuon (const int &p)
template<class T>
bool	isTau (const T &p)
template<>
bool	isTau (const int &p)
template<class T>
bool	isNeutrino (const T &p)
	APID: the fourth generation neutrinos are neutrinos.
template<>
bool	isNeutrino (const int &p)
template<class T>
bool	isSMNeutrino (const T &p)
template<>
bool	isSMNeutrino (const int &p)
template<class T>
bool	isFourthGeneration (const T &p)
	Is this a 4th generation fermion?
template<>
bool	isFourthGeneration (const int &p)
template<class T>
bool	isDiquark (const T &p)
	PDG rule 4 Diquarks have 4-digit numbers with nq1 >= nq2 and nq3 = 0 APID: states with top quarks are diquarks APID: states with fourth generation quarks are not diquarks.
template<>
bool	isDiquark (const DecodedPID &p)
template<>
bool	isDiquark (const int &p)
template<class T>
bool	isMeson (const T &p)
	Table 43.1 PDG rule 5a: The numbers specifying the meson’s quark content conform to the convention nq1= 0 and nq2 >= nq3.
template<>
bool	isMeson (const DecodedPID &p)
template<>
bool	isMeson (const int &p)
template<class T>
bool	isQuarkonium (const T &p)
	Is this a heavy-flavour quarkonium meson?
template<>
bool	isQuarkonium (const DecodedPID &p)
template<>
bool	isQuarkonium (const int &p)
template<class T>
bool	isBaryon (const T &p)
	Table 43.2 APID: states with fourth generation quarks are not baryons.
template<>
bool	isBaryon (const DecodedPID &p)
template<>
bool	isBaryon (const int &p)
template<class T>
bool	isTetraquark (const T &p)
	PDG rule 14 The 9-digit tetra-quark codes are ±1nrnLnq1nq20nq3nq4nJ.
template<>
bool	isTetraquark (const DecodedPID &p)
template<>
bool	isTetraquark (const int &p)
template<class T>
bool	isPentaquark (const T &p)
	PDG rule 15 The 9-digit penta-quark codes are ±1nrnLnq1nq2nq3nq4nq5nJ, sorted such that nq1≥nq2≥nq3≥nq4.
template<>
bool	isPentaquark (const DecodedPID &p)
template<>
bool	isPentaquark (const int &p)
template<class T>
bool	isHadron (const T &p)
template<>
bool	isHadron (const DecodedPID &p)
template<>
bool	isHadron (const int &p)
template<class T>
bool	isTrajectory (const T &p)
	PDG rule 8: The pomeron and odderon trajectories and a generic reggeon trajectory of states in QCD areassigned codes 990, 9990, and 110 respectively.
template<>
bool	isTrajectory (const int &p)
template<class T>
bool	isBoson (const T &p)
	PDG rule 9: Two-digit numbers in the range 21–30 are provided for the Standard Model gauge and Higgs bosons.
template<>
bool	isBoson (const int &p)
template<>
bool	isBoson (const DecodedPID &p)
template<class T>
bool	isGluon (const T &p)
template<>
bool	isGluon (const int &p)
template<class T>
bool	isPhoton (const T &p)
template<>
bool	isPhoton (const int &p)
template<class T>
bool	isZ (const T &p)
template<>
bool	isZ (const int &p)
template<class T>
bool	isW (const T &p)
template<>
bool	isW (const int &p)
template<class T>
bool	isHeavyBoson (const T &p)
	APID: Additional "Heavy"/"prime" versions of W and Z bosons (Used in MCTruthClassifier).
template<>
bool	isHeavyBoson (const int &p)
template<class T>
bool	isHiggs (const T &p)
	APID: HIGGS boson is only one particle.
template<>
bool	isHiggs (const int &p)
template<class T>
bool	isMSSMHiggs (const T &p)
	APID: Additional Higgs bosons for MSSM (Used in MCTruthClassifier).
template<>
bool	isMSSMHiggs (const int &p)
template<class T>
bool	isGraviton (const T &p)
template<>
bool	isGraviton (const int &p)
template<class T>
bool	isResonance (const T &p)
template<class T>
bool	isLeptoQuark (const T &p)
	PDG rule 11c: “One-of-a-kind” exotic particles are assigned numbers in the range 41–80.
template<>
bool	isLeptoQuark (const int &p)
template<class T>
bool	isPythia8Specific (const T &p)
template<>
bool	isPythia8Specific (const DecodedPID &p)
template<>
bool	isPythia8Specific (const int &p)
template<class T>
bool	isNeutrinoRH (const T &p)
	PDG Rule 12: APID: Helper function for right-handed neutrino states These are generator defined PDG ID values for right handed neutrinos.
template<>
bool	isNeutrinoRH (const int &p)
template<class T>
bool	isGenSpecific (const T &p)
	Main Table for MC internal use 81–100,901–930,998-999,1901–1930,2901–2930, and 3901–3930.
template<>
bool	isGenSpecific (const int &p)
template<class T>
bool	isGeantino (const T &p)
template<>
bool	isGeantino (const int &p)
template<class T>
bool	isGlueball (const T &p)
	APID: Definition of Glueballs: SM glueballs 99X (X=1,5), 999Y (Y=3,7).
template<>
bool	isGlueball (const DecodedPID &p)
template<>
bool	isGlueball (const int &p)
template<class T>
bool	isSquark (const T &p)
	PDG rule 11d Fundamental supersymmetric particles are identified by adding a nonzero n to the particle number.
template<>
bool	isSquark (const DecodedPID &p)
template<>
bool	isSquark (const int &p)
template<class T>
bool	isSquarkLH (const T &p)
template<>
bool	isSquarkLH (const DecodedPID &p)
template<>
bool	isSquarkLH (const int &p)
template<class T>
bool	isSquarkRH (const T &p)
template<>
bool	isSquarkRH (const DecodedPID &p)
template<>
bool	isSquarkRH (const int &p)
template<class T>
bool	isSlepton (const T &p)
template<>
bool	isSlepton (const DecodedPID &p)
template<>
bool	isSlepton (const int &p)
template<class T>
bool	isSleptonLH (const T &p)
template<>
bool	isSleptonLH (const DecodedPID &p)
template<>
bool	isSleptonLH (const int &p)
template<class T>
bool	isSleptonRH (const T &p)
template<>
bool	isSleptonRH (const DecodedPID &p)
template<>
bool	isSleptonRH (const int &p)
template<class T>
bool	isGaugino (const T &p)
template<>
bool	isGaugino (const DecodedPID &p)
template<>
bool	isGaugino (const int &p)
template<class T>
bool	isSuperpartner (const T &p)
template<>
bool	isSuperpartner (const DecodedPID &p)
template<>
bool	isSuperpartner (const int &p)
template<class T>
bool	isTechnicolor (const T &p)
	PDG rule 11e Technicolor states have n = 3, with technifermions treated like ordinary fermions.
template<>
bool	isTechnicolor (const DecodedPID &p)
template<>
bool	isTechnicolor (const int &p)
template<class T>
bool	isExcited (const T &p)
	PDG rule 11f Excited (composite) quarks and leptons are identified by setting n= 4 and nr= 0.
template<>
bool	isExcited (const DecodedPID &p)
template<>
bool	isExcited (const int &p)
template<class T>
bool	isRGlueball (const T &p)
	PDG rule 11g: Within several scenarios of new physics, it is possible to have colored particles sufficiently long-lived for color-singlet hadronic states to form around them.
template<>
bool	isRGlueball (const DecodedPID &p)
template<>
bool	isRGlueball (const int &p)
template<class T>
bool	isRMeson (const T &p)
template<>
bool	isRMeson (const DecodedPID &p)
template<>
bool	isRMeson (const int &p)
template<class T>
bool	isRBaryon (const T &p)
template<>
bool	isRBaryon (const DecodedPID &p)
template<>
bool	isRBaryon (const int &p)
template<class T>
bool	isRHadron (const T &p)
template<>
bool	isRHadron (const DecodedPID &p)
template<>
bool	isRHadron (const int &p)
template<class T>
bool	hasSquark (const T &p, const int &q)
template<>
bool	hasSquark (const DecodedPID &p, const int &q)
template<>
bool	hasSquark (const int &p, const int &q)
template<class T>
bool	isSUSY (const T &p)
template<>
bool	isSUSY (const DecodedPID &p)
template<>
bool	isSUSY (const int &p)
template<class T>
bool	isKK (const T &p)
	PDG rule 11h A black hole in models with extra dimensions has code 5000040.
template<>
bool	isKK (const DecodedPID &p)
template<>
bool	isKK (const int &p)
template<class T>
bool	isMonopole (const T &p)
	PDG rule 11i Magnetic monopoles and dyons are assumed to have one unit of Dirac monopole charge and a variable integer number nq1nq2 nq3 units of electric charge.
template<>
bool	isMonopole (const DecodedPID &p)
template<>
bool	isMonopole (const int &p)
template<class T>
bool	isDM (const T &p)
	PDG rule 11j: The nature of Dark Matter (DM) is not known, and therefore a definitive classificationis too early.
template<>
bool	isDM (const int &p)
template<class T>
bool	isHiddenValley (const T &p)
	PDG rule 11k Hidden Valley particles have n = 4 and n_r = 9, and trailing numbers in agreement with their nearest-analog standard particles, as far as possible.
template<>
bool	isHiddenValley (const DecodedPID &p)
template<>
bool	isHiddenValley (const int &p)
template<class T>
bool	isGenericMultichargedParticle (const T &p)
	In addition, there is a need to identify ”Q-ball” and similar very exotic (multi-charged) particles which may have large, non-integer charge.
template<>
bool	isGenericMultichargedParticle (const DecodedPID &p)
template<>
bool	isGenericMultichargedParticle (const int &p)
template<class T>
bool	isNucleus (const T &p)
	PDG rule 16 Nuclear codes are given as 10-digit numbers ±10LZZZAAAI.
template<>
bool	isNucleus (const DecodedPID &p)
template<>
bool	isNucleus (const int &p)
template<class T>
bool	hasQuark (const T &p, const int &q)
template<>
bool	hasQuark (const DecodedPID &p, const int &q)
template<>
bool	hasQuark (const int &p, const int &q)
template<class T>
bool	hasStrange (const T &p)
template<class T>
bool	hasCharm (const T &p)
template<class T>
bool	hasBottom (const T &p)
template<class T>
bool	hasTop (const T &p)
template<class T>
int	baryonNumber3 (const T &p)
template<>
int	baryonNumber3 (const DecodedPID &p)
template<>
int	baryonNumber3 (const int &p)
template<class T>
double	baryonNumber (const T &p)
template<>
double	baryonNumber (const DecodedPID &p)
template<>
double	baryonNumber (const int &p)
template<class T>
int	strangeness (const T &p)
template<>
int	strangeness (const DecodedPID &p)
template<>
int	strangeness (const int &p)
template<class T>
int	numberOfLambdas (const T &p)
template<>
int	numberOfLambdas (const DecodedPID &p)
template<>
int	numberOfLambdas (const int &p)
template<class T>
int	numberOfProtons (const T &p)
template<>
int	numberOfProtons (const DecodedPID &p)
template<>
int	numberOfProtons (const int &p)
template<class T>
bool	isBSM (const T &p)
	APID: graviton and all Higgs extensions are BSM.
template<>
bool	isBSM (const DecodedPID &p)
template<>
bool	isBSM (const int &p)
template<class T>
bool	isTransportable (const T &p)
template<>
bool	isTransportable (const DecodedPID &p)
template<>
bool	isTransportable (const int &p)
template<class T>
bool	isValid (const T &p)
	Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
template<>
bool	isValid (const DecodedPID &p)
template<>
bool	isValid (const int &p)
template<class T>
int	leadingQuark (const T &p)
template<>
int	leadingQuark (const DecodedPID &p)
template<>
int	leadingQuark (const int &p)
template<class T>
bool	isLightHadron (const T &p)
template<class T>
bool	isHeavyHadron (const T &p)
template<class T>
bool	isStrangeHadron (const T &p)
template<class T>
bool	isCharmHadron (const T &p)
template<class T>
bool	isBottomHadron (const T &p)
template<class T>
bool	isTopHadron (const T &p)
template<class T>
bool	isLightMeson (const T &p)
template<class T>
bool	isHeavyMeson (const T &p)
template<class T>
bool	isStrangeMeson (const T &p)
template<class T>
bool	isCharmMeson (const T &p)
template<class T>
bool	isBottomMeson (const T &p)
template<class T>
bool	isTopMeson (const T &p)
template<class T>
bool	isCCbarMeson (const T &p)
template<>
bool	isCCbarMeson (const DecodedPID &p)
template<>
bool	isCCbarMeson (const int &p)
template<class T>
bool	isBBbarMeson (const T &p)
template<>
bool	isBBbarMeson (const DecodedPID &p)
template<>
bool	isBBbarMeson (const int &p)
template<class T>
bool	isLightBaryon (const T &p)
template<class T>
bool	isHeavyBaryon (const T &p)
template<class T>
bool	isStrangeBaryon (const T &p)
template<class T>
bool	isCharmBaryon (const T &p)
template<class T>
bool	isBottomBaryon (const T &p)
template<class T>
bool	isTopBaryon (const T &p)
template<class T>
bool	isWeaklyDecayingBHadron (const T &p)
template<>
bool	isWeaklyDecayingBHadron (const int &p)
template<>
bool	isWeaklyDecayingBHadron (const DecodedPID &p)
template<class T>
bool	isWeaklyDecayingCHadron (const T &p)
template<>
bool	isWeaklyDecayingCHadron (const int &p)
template<>
bool	isWeaklyDecayingCHadron (const DecodedPID &p)
template<class T>
int	charge3 (const T &p)
template<class T>
double	fractionalCharge (const T &p)
template<class T>
double	charge (const T &p)
template<class T>
double	threeCharge (const T &p)
template<class T>
bool	isCharged (const T &p)
template<>
int	charge3 (const DecodedPID &p)
template<>
int	charge3 (const int &p)
template<class T>
bool	isNeutral (const T &p)
template<>
bool	isNeutral (const DecodedPID &p)
template<>
bool	isNeutral (const int &p)
template<>
double	fractionalCharge (const DecodedPID &p)
template<>
double	fractionalCharge (const int &p)
template<class T>
bool	isEMInteracting (const T &p)
template<>
bool	isEMInteracting (const int &p)
template<class T>
bool	isParton (const T &p)
template<class T>
int	spin2 (const T &p)
template<>
int	spin2 (const DecodedPID &p)
template<>
int	spin2 (const int &p)
template<class T>
double	spin (const T &p)
template<>
double	spin (const DecodedPID &p)
template<>
double	spin (const int &p)
template<class T>
std::vector< int >	containedQuarks (const T &p)
template<>
std::vector< int >	containedQuarks (const int &p)
template<>
std::vector< int >	containedQuarks (const DecodedPID &p)
template<class T>
bool	isStrongInteracting (const T &p)
template<>
bool	isStrongInteracting (const int &p)
template<class T>
bool	isInteracting (const T &p)
	Identify if the particle with given PDG ID would not interact with the detector, i.e. not a neutrino or WIMP.
template<class T>
bool	isChargedNonShowering (const T &p)
	Identify if the particle with given PDG ID would produce ID tracks but not shower in the detector if stable.
template<class T>
bool	isBeam (const T &p)
	Identify if the particle is beam particle.
template<class T>
bool	isDecayed (const T &p)
	Identify if the particle decayed.
template<class T>
bool	isStable (const T &p)
	Identify if the particle is stable, i.e. has not decayed.
template<class T>
bool	isFinalState (const T &p)
	Identify if the particle is final state particle.
template<class T>
bool	isPhysical (const T &p)
	Identify if the particle is physical, i.e. is stable or decayed.
template<class T>
bool	isGenStable (const T &p)
	Determine if the particle is stable at the generator (not det-sim) level,.
template<class T>
bool	isSimStable (const T &p)
	Identify if the particle is considered stable at the post-detector-sim stage.
template<class T>
bool	isSimInteracting (const T &p)
	Identify if the particle could interact with the detector during the simulation, e.g. not a neutrino or WIMP.
template<class T>
bool	isStableOrSimDecayed (const T &p)
	Identify if particle is satble or decayed in simulation.
template<class T>
bool	isZeroEnergyPhoton (const T &p)
	Identify a photon with zero energy. Probably a workaround for a generator bug.
template<class T>
bool	isSpecialNonInteracting (const T &p)
	Identify a special non-interacting particles.
template<class T>
T	findMother (T thePart)
	Function to get a mother of particle. MCTruthClassifier legacy.
template<class C, class T>
T	findMatching (C TruthContainer, T p)
	Function to find a particle in container.
template<class T>
void	findParticleAncestors (T thePart, std::set< T > &allancestors)
	Function to find all ancestors of the particle.
template<class T>
void	findParticleStableDescendants (T thePart, std::set< T > &allstabledescendants)
	Function to get the particle stable MC daughters.
template<class T>
bool	isHardScatteringVertex (T pVert)
	Function to classify the vertex as hard scattering vertex.
template<class T, class U>
bool	isFromHadron (T p, U hadron, bool &fromTau, bool &fromBSM)
	Function to classify the particle.
template<class T>
auto	findSimulatedEndVertex (T thePart) -> decltype(thePart->end_vertex())
	Function to find the end vertex of a particle.
template<class V>
auto	findFinalStateParticles (V theVert) -> decltype(theVert->particles_out())
	Function to find the stable particle descendants of the given vertex..
void	GeVToMeV (HepMC::GenEvent *evt)
void	MeVToGeV (HepMC::GenEvent *evt)

Variables
static const int	TABLESIZE = 100
static const std::array< int, TABLESIZE >	triple_charge
static const std::array< int, TABLESIZE >	double_spin
static const int	DQUARK = 1
static const int	UQUARK = 2
static const int	SQUARK = 3
static const int	CQUARK = 4
static const int	BQUARK = 5
static const int	TQUARK = 6
static const int	BPRIME = 7
static const int	TPRIME = 8
static const int	QUARK_LIMIT = BPRIME
static const int	ELECTRON = 11
static const int	POSITRON = -ELECTRON
static const int	NU_E = 12
static const int	MUON = 13
static const int	NU_MU = 14
static const int	TAU = 15
static const int	NU_TAU = 16
static const int	LPRIME = 17
static const int	NUPRIME = 18
static const int	GLUON = 21
static const int	COMPOSITEGLUON = 9
static const int	PHOTON = 22
static const int	Z0BOSON = 23
static const int	WPLUSBOSON = 24
static const int	HIGGSBOSON = 25
static const int	ZPRIME = 32
static const int	ZDBLPRIME = 33
static const int	WPLUSPRIME = 34
static const int	HIGGS2 = 35
static const int	HIGGS3 = 36
static const int	HIGGSPLUS = 37
static const int	HIGGSPLUSPLUS = 38
static const int	GRAVITON = 39
static const int	HIGGS4 = 40
static const int	LEPTOQUARK = 42
static const int	DARKPHOTON = 60000
	PDG Ids for Mavtop madgraph UFO model found under DarkX.
static const int	MAVTOP = 60001
static const int	PIPLUS = 211
static const int	PIMINUS = -PIPLUS
static const int	PI0 = 111
static const int	K0L = 130
static const int	K0S = 310
static const int	K0 = 311
static const int	KPLUS = 321
static const int	DPLUS = 411
static const int	DSTAR = 413
static const int	D0 = 421
static const int	DSPLUS = 431
static const int	JPSI = 443
static const int	B0 = 511
static const int	BCPLUS = 541
static const int	PROTON = 2212
static const int	NEUTRON = 2112
static const int	LAMBDA0 = 3122
static const int	LAMBDACPLUS = 4122
static const int	LAMBDAB0 = 5122
static const int	PSI2S = 20443
static const int	RH_NU_E = 9900012
	PDG Rule 12: Generator defined PDG ID values for right handed neutrinos and corresponding W+ boson from a Left-Right symmetric Standard Model extension.
static const int	RH_NU_MU = 9900014
static const int	RH_NU_TAU = 9900016
static const int	WBOSON_LRSM = 9900024
static const int	LEAD = 1000822080
static const int	INDIUM = 1000491150
static const int	KRYPTON = 1000360840
static const int	CALCIUM = 1000200400
static const int	ARGON = 1000180400
static const int	MAGNESIUM = 1000120240
static const int	NEON = 1000100200
static const int	OXYGEN = 1000080160
static const int	BORON = 1000050110
static const int	HELIUM = 1000020040
static const int	POMERON = 990
	PDG rule 8: The pomeron and odderon trajectories and a generic reggeon trajectory of states in QCD areassigned codes 990, 9990, and 110 respectively.
static const int	ODDERON = 9990
static const int	REGGEON = 110
static const int	GEANTINOPLUS = 998
	PDG rule 10: Codes 81–100 are reserved for generator-specific pseudoparticles and concepts.
static const int	GEANTINO0 = 999
static const std::array< int, 10 >	is_strange

Function Documentation

baryonNumber() [1/3]

template<>

double MC::baryonNumber ( const DecodedPID & p )

inline

Definition at line 781 of file HepMCHelpers.h.

baryonNumber() [2/3]

template<>

double MC::baryonNumber ( const int & p )

inline

Definition at line 782 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

baryonNumber() [3/3]

template<class T>

double MC::baryonNumber ( const T & p )

inline

Definition at line 780 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

baryonNumber3() [1/3]

template<>

int MC::baryonNumber3 ( const DecodedPID & p )

inline

Definition at line 756 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

baryonNumber3() [2/3]

template<>

int MC::baryonNumber3 ( const int & p )

inline

Definition at line 778 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

baryonNumber3() [3/3]

template<class T>

int MC::baryonNumber3 ( const T & p )

inline

Definition at line 755 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

charge()

template<class T>

double MC::charge ( const T & p )

inline

Definition at line 1004 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

charge3() [1/3]

template<>

int MC::charge3 ( const DecodedPID & p )

inline

Codes 411nq1nq2 nq3 0 are then used when the magnetic and electrical charge sign agree and 412nq1nq2 nq3 0 when they disagree, with the overall sign of the particle set by the magnetic charge.

Definition at line 1014 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

charge3() [2/3]

template<>

int MC::charge3 ( const int & p )

inline

Definition at line 1088 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

charge3() [3/3]

template<class T>

int MC::charge3 ( const T & p )

inline

Definition at line 1002 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

containedQuarks() [1/3]

template<>

std::vector< int > MC::containedQuarks ( const DecodedPID & p )

inline

Definition at line 1187 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

containedQuarks() [2/3]

template<>

std::vector< int > MC::containedQuarks ( const int & p )

inline

Definition at line 1165 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

containedQuarks() [3/3]

template<class T>

std::vector< int > MC::containedQuarks ( const T & p )

inline

Definition at line 1164 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

findFinalStateParticles()

template<class V>

auto MC::findFinalStateParticles

(

V

theVert

)

-> decltype(theVert->particles_out())

Function to find the stable particle descendants of the given vertex..

This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex* and particle counterparts

Definition at line 247 of file HepMCHelpers.h.

                                                                                                   {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }

findMatching()

template<class C, class T>

T MC::findMatching	(	C	TruthContainer,
		T	p )

Function to find a particle in container.

This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex*

Definition at line 118 of file HepMCHelpers.h.

                                                                    {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

findMother()

template<class T>

T MC::findMother

(

T

thePart

)

Function to get a mother of particle. MCTruthClassifier legacy.

This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex*

Definition at line 86 of file HepMCHelpers.h.

                                             {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }

findParticleAncestors()

template<class T>

void MC::findParticleAncestors	(	T	thePart,
		std::set< T > &	allancestors )

Function to find all ancestors of the particle.

This can be used for HepMC3::GenParticlePtr, HepMC3::ConstGenParticlePtr or xAOD::TruthParticle*

Definition at line 141 of file HepMCHelpers.h.

                                                                                    {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }

findParticleStableDescendants()

template<class T>

void MC::findParticleStableDescendants	(	T	thePart,
		std::set< T > &	allstabledescendants )

Function to get the particle stable MC daughters.

This can be used for HepMC3::GenParticlePtr, HepMC3::ConstGenParticlePtr or xAOD::TruthParticle*

Definition at line 153 of file HepMCHelpers.h.

                                                                                                    {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }

findSimulatedEndVertex()

template<class T>

auto MC::findSimulatedEndVertex

(

T

thePart

)

-> decltype(thePart->end_vertex())

Function to find the end vertex of a particle.

This algorithm allows for 1->1 decays. This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex* and particle counterparts

Definition at line 219 of file HepMCHelpers.h.

                                                                                               {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }

fractionalCharge() [1/3]

template<>

double MC::fractionalCharge ( const DecodedPID & p )

inline

Definition at line 1101 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

fractionalCharge() [2/3]

template<>

double MC::fractionalCharge ( const int & p )

inline

Definition at line 1108 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

fractionalCharge() [3/3]

template<class T>

double MC::fractionalCharge ( const T & p )

inline

Definition at line 1003 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

GeVToMeV()

void MC::GeVToMeV ( HepMC::GenEvent * evt )

inline

Definition at line 266 of file HepMCHelpers.h.

{ for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}

hasBottom()

template<class T>

bool MC::hasBottom ( const T & p )

inline

Definition at line 745 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

hasCharm()

template<class T>

bool MC::hasCharm ( const T & p )

inline

Definition at line 744 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

hasQuark() [1/3]

template<>

bool MC::hasQuark ( const DecodedPID & p, const int & q )

inline

Definition at line 723 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

hasQuark() [2/3]

template<>

bool MC::hasQuark ( const int & p, const int & q )

inline

Definition at line 741 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

hasQuark() [3/3]

template<class T>

bool MC::hasQuark ( const T & p, const int & q )

inline

hasSquark() [1/3]

template<>

bool MC::hasSquark ( const DecodedPID & p, const int & q )

inline

Definition at line 618 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

hasSquark() [2/3]

template<>

bool MC::hasSquark ( const int & p, const int & q )

inline

Definition at line 625 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

hasSquark() [3/3]

template<class T>

bool MC::hasSquark ( const T & p, const int & q )

inline

Definition at line 617 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

hasStrange()

template<class T>

bool MC::hasStrange ( const T & p )

inline

Definition at line 743 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

hasTop()

template<class T>

bool MC::hasTop ( const T & p )

inline

Definition at line 746 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBaryon() [1/3]

template<>

bool MC::isBaryon ( const DecodedPID & p )

inline

Definition at line 290 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBaryon() [2/3]

template<>

bool MC::isBaryon ( const int & p )

inline

Definition at line 323 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBaryon() [3/3]

template<class T>

bool MC::isBaryon ( const T & p )

inline

Table 43.2 APID: states with fourth generation quarks are not baryons.

Definition at line 289 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBBbarMeson() [1/3]

template<>

bool MC::isBBbarMeson ( const DecodedPID & p )

inline

Definition at line 934 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBBbarMeson() [2/3]

template<>

bool MC::isBBbarMeson ( const int & p )

inline

Definition at line 935 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBBbarMeson() [3/3]

template<class T>

bool MC::isBBbarMeson ( const T & p )

inline

Definition at line 933 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBeam()

template<class T>

bool MC::isBeam ( const T & p )

inline

Identify if the particle is beam particle.

Definition at line 40 of file HepMCHelpers.h.

{ return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

isBoson() [1/3]

template<>

bool MC::isBoson ( const DecodedPID & p )

inline

Definition at line 378 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBoson() [2/3]

template<>

bool MC::isBoson ( const int & p )

inline

Definition at line 377 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBoson() [3/3]

template<class T>

bool MC::isBoson ( const T & p )

inline

PDG rule 9: Two-digit numbers in the range 21–30 are provided for the Standard Model gauge and Higgs bosons.

PDG rule 11b: The graviton and the boson content of a two-Higgs-doublet scenario and of additional SU(2)×U(1) groups are found in the range 31–40.

Definition at line 376 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBottom() [1/2]

template<>

bool MC::isBottom ( const int & p )

inline

Definition at line 190 of file HepMCHelpers.h.

isBottom() [2/2]

template<class T>

bool MC::isBottom ( const T & p )

inline

Definition at line 189 of file HepMCHelpers.h.

isBottomBaryon()

template<class T>

bool MC::isBottomBaryon ( const T & p )

inline

Definition at line 942 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBottomHadron()

template<class T>

bool MC::isBottomHadron ( const T & p )

inline

Definition at line 919 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBottomMeson()

template<class T>

bool MC::isBottomMeson ( const T & p )

inline

Definition at line 926 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBSM() [1/3]

template<>

bool MC::isBSM ( const DecodedPID & p )

inline

Definition at line 854 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBSM() [2/3]

template<>

bool MC::isBSM ( const int & p )

inline

Definition at line 871 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isBSM() [3/3]

template<class T>

bool MC::isBSM ( const T & p )

inline

APID: graviton and all Higgs extensions are BSM.

Definition at line 853 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isCCbarMeson() [1/3]

template<>

bool MC::isCCbarMeson ( const DecodedPID & p )

inline

Definition at line 930 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isCCbarMeson() [2/3]

template<>

bool MC::isCCbarMeson ( const int & p )

inline

Definition at line 931 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isCCbarMeson() [3/3]

template<class T>

bool MC::isCCbarMeson ( const T & p )

inline

Definition at line 929 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isCharged()

template<class T>

bool MC::isCharged ( const T & p )

inline

Definition at line 1011 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isChargedNonShowering()

template<class T>

bool MC::isChargedNonShowering ( const T & p )

inline

Identify if the particle with given PDG ID would produce ID tracks but not shower in the detector if stable.

Definition at line 37 of file HepMCHelpers.h.

{ return (isMuon<T>(p) || isSUSY<T>(p)); }

isCharm() [1/2]

template<>

bool MC::isCharm ( const int & p )

inline

Definition at line 187 of file HepMCHelpers.h.

isCharm() [2/2]

template<class T>

bool MC::isCharm ( const T & p )

inline

Definition at line 186 of file HepMCHelpers.h.

isCharmBaryon()

template<class T>

bool MC::isCharmBaryon ( const T & p )

inline

Definition at line 941 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isCharmHadron()

template<class T>

bool MC::isCharmHadron ( const T & p )

inline

Definition at line 918 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isCharmMeson()

template<class T>

bool MC::isCharmMeson ( const T & p )

inline

Definition at line 925 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isChLepton() [1/2]

template<>

bool MC::isChLepton ( const int & p )

inline

Definition at line 207 of file HepMCHelpers.h.

{

isChLepton() [2/2]

template<class T>

bool MC::isChLepton ( const T & p )

inline

APID: the fourth generation leptons are leptons.

Definition at line 206 of file HepMCHelpers.h.

isDecayed()

template<class T>

bool MC::isDecayed ( const T & p )

inline

Identify if the particle decayed.

Definition at line 43 of file HepMCHelpers.h.

{ return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

isDiquark() [1/3]

template<>

bool MC::isDiquark ( const DecodedPID & p )

inline

Definition at line 235 of file HepMCHelpers.h.

isDiquark() [2/3]

template<>

bool MC::isDiquark ( const int & p )

inline

Definition at line 241 of file HepMCHelpers.h.

isDiquark() [3/3]

template<class T>

bool MC::isDiquark ( const T & p )

inline

PDG rule 4 Diquarks have 4-digit numbers with nq1 >= nq2 and nq3 = 0 APID: states with top quarks are diquarks APID: states with fourth generation quarks are not diquarks.

Definition at line 234 of file HepMCHelpers.h.

{

isDM() [1/2]

template<>

bool MC::isDM ( const int & p )

inline

Definition at line 666 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isDM() [2/2]

template<class T>

bool MC::isDM ( const T & p )

inline

PDG rule 11j: The nature of Dark Matter (DM) is not known, and therefore a definitive classificationis too early.

Candidates within specific scenarios are classified therein, such as 1000022 for the lightest neutralino. Generic fundamental states can be given temporary codes in the range 51 - 60, with 51, 52 and 53 reserved for spin 0, 1/2 and 1 ones (this could also be an axion state). Generic mediators of s-channel DM pair creation of annihilation can be given codes 54 and 55 for spin 0 or 1 ones. Separate antiparticles, with negativecodes, may or may not exist. More elaborate new scenarios should be constructed with n= 5 and nr = 9.

Definition at line 665 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isElectron() [1/2]

template<>

bool MC::isElectron ( const int & p )

inline

Definition at line 210 of file HepMCHelpers.h.

isElectron() [2/2]

template<class T>

bool MC::isElectron ( const T & p )

inline

Definition at line 209 of file HepMCHelpers.h.

isEMInteracting() [1/2]

template<>

bool MC::isEMInteracting ( const int & p )

inline

Definition at line 1112 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isEMInteracting() [2/2]

template<class T>

bool MC::isEMInteracting ( const T & p )

inline

Definition at line 1111 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isExcited() [1/3]

template<>

bool MC::isExcited ( const DecodedPID & p )

inline

Definition at line 545 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isExcited() [2/3]

template<>

bool MC::isExcited ( const int & p )

inline

Definition at line 550 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isExcited() [3/3]

template<class T>

bool MC::isExcited ( const T & p )

inline

PDG rule 11f Excited (composite) quarks and leptons are identified by setting n= 4 and nr= 0.

Definition at line 543 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isFinalState()

template<class T>

bool MC::isFinalState ( const T & p )

inline

Identify if the particle is final state particle.

Definition at line 49 of file HepMCHelpers.h.

{ return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

isFourthGeneration() [1/2]

template<>

bool MC::isFourthGeneration ( const int & p )

inline

Definition at line 228 of file HepMCHelpers.h.

: outgoing) {

isFourthGeneration() [2/2]

template<class T>

bool MC::isFourthGeneration ( const T & p )

inline

Is this a 4th generation fermion?

APID: 4th generation fermions are not standard model particles

Definition at line 227 of file HepMCHelpers.h.

isFromHadron()

template<class T, class U>

bool MC::isFromHadron	(	T	p,
		U	hadron,
		bool &	fromTau,
		bool &	fromBSM )

Function to classify the particle.

AV: This is MCtruthClassifier legacy. The function should be improved in the future. This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex*

Definition at line 195 of file HepMCHelpers.h.

                                                                                               {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }

isGaugino() [1/3]

template<>

bool MC::isGaugino ( const DecodedPID & p )

inline

Definition at line 512 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGaugino() [2/3]

template<>

bool MC::isGaugino ( const int & p )

inline

Definition at line 515 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGaugino() [3/3]

template<class T>

bool MC::isGaugino ( const T & p )

inline

Definition at line 511 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGeantino() [1/2]

template<>

bool MC::isGeantino ( const int & p )

inline

Definition at line 445 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGeantino() [2/2]

template<class T>

bool MC::isGeantino ( const T & p )

inline

Definition at line 444 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGenericMultichargedParticle() [1/3]

template<>

bool MC::isGenericMultichargedParticle ( const DecodedPID & p )

inline

Definition at line 692 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGenericMultichargedParticle() [2/3]

template<>

bool MC::isGenericMultichargedParticle ( const int & p )

inline

Definition at line 693 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGenericMultichargedParticle() [3/3]

template<class T>

bool MC::isGenericMultichargedParticle ( const T & p )

inline

In addition, there is a need to identify ”Q-ball” and similar very exotic (multi-charged) particles which may have large, non-integer charge.

These particles are assigned the ad-hoc numbering +/-100XXXY0, where the charge is XXX.Y. or +/-200XXYY0, where the charge is XX/YY. The case of +/-200XXYY0 is legacy, see https://gitlab.cern.ch/atlas/athena/-/merge_requests/25862 Note that no other quantum numbers besides the charge are considered for these generic multi-charged particles (e.g. isSUSY() is false for them). Such a model was used in previous Run-1 (1301.5272,1504.04188) and Run-2 (1812.03673,2303.13613) ATLAS searches.

Definition at line 691 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGenSpecific() [1/2]

template<>

bool MC::isGenSpecific ( const int & p )

inline

Definition at line 433 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGenSpecific() [2/2]

template<class T>

bool MC::isGenSpecific ( const T & p )

inline

Main Table for MC internal use 81–100,901–930,998-999,1901–1930,2901–2930, and 3901–3930.

Definition at line 432 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGenStable()

template<class T>

bool MC::isGenStable ( const T & p )

inline

Determine if the particle is stable at the generator (not det-sim) level,.

Definition at line 55 of file HepMCHelpers.h.

{ return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

isGlueball() [1/3]

template<>

bool MC::isGlueball ( const DecodedPID & p )

inline

Definition at line 449 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGlueball() [2/3]

template<>

bool MC::isGlueball ( const int & p )

inline

Definition at line 455 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGlueball() [3/3]

template<class T>

bool MC::isGlueball ( const T & p )

inline

APID: Definition of Glueballs: SM glueballs 99X (X=1,5), 999Y (Y=3,7).

Definition at line 448 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGluon() [1/2]

template<>

bool MC::isGluon ( const int & p )

inline

Definition at line 381 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGluon() [2/2]

template<class T>

bool MC::isGluon ( const T & p )

inline

Definition at line 380 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGraviton() [1/2]

template<>

bool MC::isGraviton ( const int & p )

inline

Definition at line 405 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isGraviton() [2/2]

template<class T>

bool MC::isGraviton ( const T & p )

inline

Definition at line 404 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHadron() [1/3]

template<>

bool MC::isHadron ( const DecodedPID & p )

inline

Definition at line 359 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHadron() [2/3]

template<>

bool MC::isHadron ( const int & p )

inline

Definition at line 360 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHadron() [3/3]

template<class T>

bool MC::isHadron ( const T & p )

inline

Definition at line 358 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHardScatteringVertex()

template<class T>

bool MC::isHardScatteringVertex

(

T

pVert

)

Function to classify the vertex as hard scattering vertex.

AV: This is MCtruthClassifier legacy. Note that this function willnot capture some cases of the HardScattering vertices. The function should be improved in the future. This can be used for HepMC3::GenVertexPtr, HepMC3::ConstGenVertexPtr or xAOD::TruthVertex*

Definition at line 169 of file HepMCHelpers.h.

                                                          {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}

isHeavyBaryon()

template<class T>

bool MC::isHeavyBaryon ( const T & p )

inline

Definition at line 939 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHeavyBoson() [1/2]

template<>

bool MC::isHeavyBoson ( const int & p )

inline

Definition at line 394 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHeavyBoson() [2/2]

template<class T>

bool MC::isHeavyBoson ( const T & p )

inline

APID: Additional "Heavy"/"prime" versions of W and Z bosons (Used in MCTruthClassifier).

Definition at line 393 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHeavyHadron()

template<class T>

bool MC::isHeavyHadron ( const T & p )

inline

Definition at line 916 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHeavyMeson()

template<class T>

bool MC::isHeavyMeson ( const T & p )

inline

Definition at line 923 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHiddenValley() [1/3]

template<>

bool MC::isHiddenValley ( const DecodedPID & p )

inline

Definition at line 677 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHiddenValley() [2/3]

template<>

bool MC::isHiddenValley ( const int & p )

inline

Definition at line 683 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHiddenValley() [3/3]

template<class T>

bool MC::isHiddenValley ( const T & p )

inline

PDG rule 11k Hidden Valley particles have n = 4 and n_r = 9, and trailing numbers in agreement with their nearest-analog standard particles, as far as possible.

Thus 4900021 is the gauge boson g_v of a confining gauge field, 490000n_{q_v} and 490001n_{l_v} fundamental constituents charged or not under this, 4900022 is the γ_v of a non-confining field, and 4900n_{q_{v1}}n_{q_{v2}}n_J a Hidden Valley meson.

Definition at line 675 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHiggs() [1/2]

template<>

bool MC::isHiggs ( const int & p )

inline

Definition at line 398 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isHiggs() [2/2]

template<class T>

bool MC::isHiggs ( const T & p )

inline

APID: HIGGS boson is only one particle.

Definition at line 397 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isInteracting()

template<class T>

bool MC::isInteracting ( const T & p )

inline

Identify if the particle with given PDG ID would not interact with the detector, i.e. not a neutrino or WIMP.

Definition at line 34 of file HepMCHelpers.h.

{ return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

isKK() [1/3]

template<>

bool MC::isKK ( const DecodedPID & p )

inline

Definition at line 643 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isKK() [2/3]

template<>

bool MC::isKK ( const int & p )

inline

Definition at line 644 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isKK() [3/3]

template<class T>

bool MC::isKK ( const T & p )

inline

PDG rule 11h A black hole in models with extra dimensions has code 5000040.

Kaluza-Klein excitations in models with extra dimensions have n = 5 or n = 6, to distinguish excitations of left-or right-handed fermions or, in case of mixing, the lighter or heavier state (cf. 11d). The non zero nr digit gives the radial excitation number, in scenarios where the level spacing allows these to be distinguished. Should the model also contain supersymmetry, excited SUSY states would be denoted by a nn_r > 0, with n = 1 or 2 as usual. Should some colored states be long-lived enough that hadrons would form around them, the coding strategy of 11g applies, with the initial two nnr digits preserved in the combined code.

Definition at line 642 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isLepton() [1/3]

template<>

bool MC::isLepton ( const DecodedPID & p )

inline

Definition at line 198 of file HepMCHelpers.h.

isLepton() [2/3]

template<>

bool MC::isLepton ( const int & p )

inline

Definition at line 197 of file HepMCHelpers.h.

isLepton() [3/3]

template<class T>

bool MC::isLepton ( const T & p )

inline

APID: the fourth generation leptons are leptons.

Definition at line 196 of file HepMCHelpers.h.

isLeptoQuark() [1/2]

template<>

bool MC::isLeptoQuark ( const int & p )

inline

Definition at line 416 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isLeptoQuark() [2/2]

template<class T>

bool MC::isLeptoQuark ( const T & p )

inline

PDG rule 11c: “One-of-a-kind” exotic particles are assigned numbers in the range 41–80.

The subrange 61-80 can be used for new heavier fermions in generic models, where partners to the SM fermions would have codes offset by 60. If required, however, other assignments could be made.

Definition at line 415 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isLightBaryon()

template<class T>

bool MC::isLightBaryon ( const T & p )

inline

Definition at line 938 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isLightHadron()

template<class T>

bool MC::isLightHadron ( const T & p )

inline

Definition at line 915 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isLightMeson()

template<class T>

bool MC::isLightMeson ( const T & p )

inline

Definition at line 922 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isMeson() [1/3]

template<>

bool MC::isMeson ( const DecodedPID & p )

inline

Definition at line 252 of file HepMCHelpers.h.

                          {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isMeson() [2/3]

template<>

bool MC::isMeson ( const int & p )

inline

Definition at line 273 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isMeson() [3/3]

template<class T>

bool MC::isMeson ( const T & p )

inline

Table 43.1 PDG rule 5a: The numbers specifying the meson’s quark content conform to the convention nq1= 0 and nq2 >= nq3.

The special case K0L is the sole exception to this rule. PDG rule 5C: The special numbers 310 and 130 are given to the K0S and K0L respectively. APID: The special code K0 is used when a generator uses K0S/K0L APID: states with fourth generation quarks are not mesons

Definition at line 251 of file HepMCHelpers.h.

: outgoing) {

isMonopole() [1/3]

template<>

bool MC::isMonopole ( const DecodedPID & p )

inline

Definition at line 653 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isMonopole() [2/3]

template<>

bool MC::isMonopole ( const int & p )

inline

Definition at line 654 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isMonopole() [3/3]

template<class T>

bool MC::isMonopole ( const T & p )

inline

PDG rule 11i Magnetic monopoles and dyons are assumed to have one unit of Dirac monopole charge and a variable integer number nq1nq2 nq3 units of electric charge.

Codes 411nq1nq2 nq3 0 are then used when the magnetic and electrical charge sign agree and 412nq1nq2 nq3 0 when they disagree, with the overall sign of the particle set by the magnetic charge. For now no spin information is provided.

Definition at line 652 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isMSSMHiggs() [1/2]

template<>

bool MC::isMSSMHiggs ( const int & p )

inline

Definition at line 402 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isMSSMHiggs() [2/2]

template<class T>

bool MC::isMSSMHiggs ( const T & p )

inline

APID: Additional Higgs bosons for MSSM (Used in MCTruthClassifier).

Definition at line 401 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isMuon() [1/2]

template<>

bool MC::isMuon ( const int & p )

inline

Definition at line 213 of file HepMCHelpers.h.

isMuon() [2/2]

template<class T>

bool MC::isMuon ( const T & p )

inline

Definition at line 212 of file HepMCHelpers.h.

isNeutral() [1/3]

template<>

bool MC::isNeutral ( const DecodedPID & p )

inline

Definition at line 1097 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isNeutral() [2/3]

template<>

bool MC::isNeutral ( const int & p )

inline

Definition at line 1098 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isNeutral() [3/3]

template<class T>

bool MC::isNeutral ( const T & p )

inline

Definition at line 1096 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isNeutrino() [1/2]

template<>

bool MC::isNeutrino ( const int & p )

inline

Definition at line 220 of file HepMCHelpers.h.

isNeutrino() [2/2]

template<class T>

bool MC::isNeutrino ( const T & p )

inline

APID: the fourth generation neutrinos are neutrinos.

Definition at line 219 of file HepMCHelpers.h.

{

isNeutrinoRH() [1/2]

template<>

bool MC::isNeutrinoRH ( const int & p )

inline

Definition at line 428 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isNeutrinoRH() [2/2]

template<class T>

bool MC::isNeutrinoRH ( const T & p )

inline

PDG Rule 12: APID: Helper function for right-handed neutrino states These are generator defined PDG ID values for right handed neutrinos.

(Defined for some MadGraph+Pythia8 samples and referenced in MCTruthClassifierGen.cxx)

Definition at line 427 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isNucleus() [1/3]

template<>

bool MC::isNucleus ( const DecodedPID & p )

inline

Definition at line 710 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isNucleus() [2/3]

template<>

bool MC::isNucleus ( const int & p )

inline

Definition at line 719 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isNucleus() [3/3]

template<class T>

bool MC::isNucleus ( const T & p )

inline

PDG rule 16 Nuclear codes are given as 10-digit numbers ±10LZZZAAAI.

For a (hyper)nucleus consisting of n_p protons, n_n neutrons and n_Λ Λ’s: A = n_p + n_n + n_Λ gives the total baryon number, Z = n_p gives the total charge, L = n_Λ gives the total number of strange quarks. I gives the isomer level, with I= 0 corresponding to the ground state and I > 0 to excitations, see [http://www.nndc.bnl.gov/amdc/web/nubase en.html], where states denoted m, n, p ,q translate to I= 1–4. As examples, the deuteron is 1000010020 and 235U is 1000922350. To avoid ambiguities, nuclear codes should not be applied to a single hadron, like p, n or Λ^0, where quark-contents-based codes already exist.

Definition at line 709 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isParton()

template<class T>

bool MC::isParton ( const T & p )

inline

Definition at line 1114 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isPentaquark() [1/3]

template<>

bool MC::isPentaquark ( const DecodedPID & p )

inline

Definition at line 350 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isPentaquark() [2/3]

template<>

bool MC::isPentaquark ( const int & p )

inline

Definition at line 355 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isPentaquark() [3/3]

template<class T>

bool MC::isPentaquark ( const T & p )

inline

PDG rule 15 The 9-digit penta-quark codes are ±1nrnLnq1nq2nq3nq4nq5nJ, sorted such that nq1≥nq2≥nq3≥nq4.

In the particle the first four are quarks and the fifth an antiquark while the opposite holds in the antiparticle, which is given with a negative sign. The nr, nL, and nJ numbers have the same meaning as for ordinary hadrons.

Definition at line 349 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isPhoton() [1/2]

template<>

bool MC::isPhoton ( const int & p )

inline

Definition at line 384 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isPhoton() [2/2]

template<class T>

bool MC::isPhoton ( const T & p )

inline

Definition at line 383 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isPhysical()

template<class T>

bool MC::isPhysical ( const T & p )

inline

Identify if the particle is physical, i.e. is stable or decayed.

Definition at line 52 of file HepMCHelpers.h.

{ return isStable<T>(p) || isDecayed<T>(p); }

isPythia8Specific() [1/3]

template<>

bool MC::isPythia8Specific ( const DecodedPID & p )

inline

Definition at line 419 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isPythia8Specific() [2/3]

template<>

bool MC::isPythia8Specific ( const int & p )

inline

Definition at line 420 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isPythia8Specific() [3/3]

template<class T>

bool MC::isPythia8Specific ( const T & p )

inline

Definition at line 418 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isQuark() [1/3]

template<>

bool MC::isQuark ( const DecodedPID & p )

inline

Definition at line 176 of file HepMCHelpers.h.

isQuark() [2/3]

template<>

bool MC::isQuark ( const int & p )

inline

Definition at line 175 of file HepMCHelpers.h.

{

isQuark() [3/3]

template<class T>

bool MC::isQuark ( const T & p )

inline

PDG rule 2: Quarks and leptons are numbered consecutively starting from 1 and 11 respectively; to do this they are first ordered by family and within families by weak isospin.

APID: the fourth generation quarks are quarks.

Definition at line 174 of file HepMCHelpers.h.

isQuarkonium() [1/3]

template<>

bool MC::isQuarkonium ( const DecodedPID & p )

inline

Definition at line 281 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isQuarkonium() [2/3]

template<>

bool MC::isQuarkonium ( const int & p )

inline

Definition at line 285 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isQuarkonium() [3/3]

template<class T>

bool MC::isQuarkonium ( const T & p )

inline

Is this a heavy-flavour quarkonium meson?

Note

Original by LHCb in Rivet analysis LHCB_2016_I1504058

phi = s,sbar is not considered quarkonium

Definition at line 280 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRBaryon() [1/3]

template<>

bool MC::isRBaryon ( const DecodedPID & p )

inline

Definition at line 597 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRBaryon() [2/3]

template<>

bool MC::isRBaryon ( const int & p )

inline

Definition at line 607 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRBaryon() [3/3]

template<class T>

bool MC::isRBaryon ( const T & p )

inline

Definition at line 596 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isResonance()

template<class T>

bool MC::isResonance ( const T & p )

inline

Definition at line 407 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRGlueball() [1/3]

template<>

bool MC::isRGlueball ( const DecodedPID & p )

inline

Definition at line 570 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRGlueball() [2/3]

template<>

bool MC::isRGlueball ( const int & p )

inline

Definition at line 577 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRGlueball() [3/3]

template<class T>

bool MC::isRGlueball ( const T & p )

inline

PDG rule 11g: Within several scenarios of new physics, it is possible to have colored particles sufficiently long-lived for color-singlet hadronic states to form around them.

In the context of supersymmetric scenarios, these states are called R-hadrons, since they carry odd R- parity. R-hadron codes, defined here, should be viewed as templates for corresponding codes also in other scenarios, for any long-lived particle that is either an unflavored color octet or a flavored color triplet. The R-hadron code is obtained by combining the SUSY particle code with a code for the light degrees of freedom, with as many intermediate zeros removed from the former as required to make place for the latter at the end. (To exemplify, a sparticle n00000n˜q combined with quarks q1 and q2 obtains code n00n˜qnq1 nq2 nJ .) Specifically, the new-particle spin decouples in the limit of large masses, so that the final nJ digit is defined by the spin state of the light-quark system alone. An appropriate number of nq digits is used to define the ordinary-quark content. As usual, 9 rather than 21 is used to denote a gluon/gluino in composite states. The sign of the hadron agrees with that of the constituent new particle (a color triplet) where there is a distinct new antiparticle, and else is defined as for normal hadrons. Particle names are R with the flavor content as lower index. APID: Definition of R-Glueballs: 100099X (X=1,3), 100999Y (Y=1,5) APID: NB In the current numbering scheme, some states with 2 gluinos + gluon or 2 gluons + gluino could have degenerate PDG_IDs.

Definition at line 569 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRHadron() [1/3]

template<>

bool MC::isRHadron ( const DecodedPID & p )

inline

Definition at line 611 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRHadron() [2/3]

template<>

bool MC::isRHadron ( const int & p )

inline

Definition at line 614 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRHadron() [3/3]

template<class T>

bool MC::isRHadron ( const T & p )

inline

Definition at line 610 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRMeson() [1/3]

template<>

bool MC::isRMeson ( const DecodedPID & p )

inline

Definition at line 582 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRMeson() [2/3]

template<>

bool MC::isRMeson ( const int & p )

inline

Definition at line 592 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isRMeson() [3/3]

template<class T>

bool MC::isRMeson ( const T & p )

inline

Definition at line 581 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSimInteracting()

template<class T>

bool MC::isSimInteracting ( const T & p )

inline

Identify if the particle could interact with the detector during the simulation, e.g. not a neutrino or WIMP.

Definition at line 61 of file HepMCHelpers.h.

{ return isGenStable<T>(p) && isInteracting<T>(p);}

isSimStable()

template<class T>

bool MC::isSimStable ( const T & p )

inline

Identify if the particle is considered stable at the post-detector-sim stage.

Definition at line 58 of file HepMCHelpers.h.

{ return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

isSlepton() [1/3]

template<>

bool MC::isSlepton ( const DecodedPID & p )

inline

Definition at line 490 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSlepton() [2/3]

template<>

bool MC::isSlepton ( const int & p )

inline

Definition at line 491 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSlepton() [3/3]

template<class T>

bool MC::isSlepton ( const T & p )

inline

Definition at line 489 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSleptonLH() [1/3]

template<>

bool MC::isSleptonLH ( const DecodedPID & p )

inline

Definition at line 496 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSleptonLH() [2/3]

template<>

bool MC::isSleptonLH ( const int & p )

inline

Definition at line 499 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSleptonLH() [3/3]

template<class T>

bool MC::isSleptonLH ( const T & p )

inline

Definition at line 495 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSleptonRH() [1/3]

template<>

bool MC::isSleptonRH ( const DecodedPID & p )

inline

Definition at line 504 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSleptonRH() [2/3]

template<>

bool MC::isSleptonRH ( const int & p )

inline

Definition at line 507 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSleptonRH() [3/3]

template<class T>

bool MC::isSleptonRH ( const T & p )

inline

Definition at line 503 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSMLepton() [1/3]

template<>

bool MC::isSMLepton ( const DecodedPID & p )

inline

Definition at line 203 of file HepMCHelpers.h.

isSMLepton() [2/3]

template<>

bool MC::isSMLepton ( const int & p )

inline

Definition at line 202 of file HepMCHelpers.h.

isSMLepton() [3/3]

template<class T>

bool MC::isSMLepton ( const T & p )

inline

APID: the fourth generation leptons are not standard model leptons.

Definition at line 201 of file HepMCHelpers.h.

isSMNeutrino() [1/2]

template<>

bool MC::isSMNeutrino ( const int & p )

inline

Definition at line 223 of file HepMCHelpers.h.

{

isSMNeutrino() [2/2]

template<class T>

bool MC::isSMNeutrino ( const T & p )

inline

Definition at line 222 of file HepMCHelpers.h.

{

isSMQuark() [1/3]

template<>

bool MC::isSMQuark ( const DecodedPID & p )

inline

Definition at line 181 of file HepMCHelpers.h.

isSMQuark() [2/3]

template<>

bool MC::isSMQuark ( const int & p )

inline

Definition at line 180 of file HepMCHelpers.h.

: nullptr;

isSMQuark() [3/3]

template<class T>

bool MC::isSMQuark ( const T & p )

inline

Definition at line 179 of file HepMCHelpers.h.

: 0;

isSpecialNonInteracting()

template<class T>

bool MC::isSpecialNonInteracting ( const T & p )

inline

Identify a special non-interacting particles.

Definition at line 75 of file HepMCHelpers.h.

                                                                     {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }

isSquark() [1/3]

template<>

bool MC::isSquark ( const DecodedPID & p )

inline

Definition at line 466 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSquark() [2/3]

template<>

bool MC::isSquark ( const int & p )

inline

Definition at line 469 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSquark() [3/3]

template<class T>

bool MC::isSquark ( const T & p )

inline

PDG rule 11d Fundamental supersymmetric particles are identified by adding a nonzero n to the particle number.

The superpartner of a boson or a left-handed fermion has n = 1 while the superpartner of a right-handed fermion has n = 2. When mixing occurs, such as between the winos and charged Higgsinos to give charginos, or between left and right sfermions, the lighter physical state is given the smaller basis state number.

Definition at line 465 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSquarkLH() [1/3]

template<>

bool MC::isSquarkLH ( const DecodedPID & p )

inline

Definition at line 474 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSquarkLH() [2/3]

template<>

bool MC::isSquarkLH ( const int & p )

inline

Definition at line 477 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSquarkLH() [3/3]

template<class T>

bool MC::isSquarkLH ( const T & p )

inline

Definition at line 473 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSquarkRH() [1/3]

template<>

bool MC::isSquarkRH ( const DecodedPID & p )

inline

Definition at line 482 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSquarkRH() [2/3]

template<>

bool MC::isSquarkRH ( const int & p )

inline

Definition at line 485 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSquarkRH() [3/3]

template<class T>

bool MC::isSquarkRH ( const T & p )

inline

Definition at line 481 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isStable()

template<class T>

bool MC::isStable ( const T & p )

inline

Identify if the particle is stable, i.e. has not decayed.

Definition at line 46 of file HepMCHelpers.h.

{ return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

isStableOrSimDecayed()

template<class T>

bool MC::isStableOrSimDecayed ( const T & p )

inline

Identify if particle is satble or decayed in simulation.

• a pathological case of decayed particle w/o end vertex. The decayed particles w/o end vertex might occur in case of simulation of long lived particles in Geant stripped off the decay products. I.e. those particles should be re-decayed later.

Definition at line 66 of file HepMCHelpers.h.

                                                                  {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

isStrange() [1/2]

template<>

bool MC::isStrange ( const int & p )

inline

Definition at line 184 of file HepMCHelpers.h.

{

isStrange() [2/2]

template<class T>

bool MC::isStrange ( const T & p )

inline

Definition at line 183 of file HepMCHelpers.h.

isStrangeBaryon()

template<class T>

bool MC::isStrangeBaryon ( const T & p )

inline

Definition at line 940 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isStrangeHadron()

template<class T>

bool MC::isStrangeHadron ( const T & p )

inline

Definition at line 917 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isStrangeMeson()

template<class T>

bool MC::isStrangeMeson ( const T & p )

inline

Definition at line 924 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isStrongInteracting() [1/2]

template<>

bool MC::isStrongInteracting ( const int & p )

inline

Definition at line 1190 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isStrongInteracting() [2/2]

template<class T>

bool MC::isStrongInteracting ( const T & p )

inline

Definition at line 1189 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSuperpartner() [1/3]

template<>

bool MC::isSuperpartner ( const DecodedPID & p )

inline

Definition at line 520 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSuperpartner() [2/3]

template<>

bool MC::isSuperpartner ( const int & p )

inline

Definition at line 523 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSuperpartner() [3/3]

template<class T>

bool MC::isSuperpartner ( const T & p )

inline

Definition at line 519 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSUSY() [1/3]

template<>

bool MC::isSUSY ( const DecodedPID & p )

inline

Definition at line 631 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSUSY() [2/3]

template<>

bool MC::isSUSY ( const int & p )

inline

Definition at line 632 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isSUSY() [3/3]

template<class T>

bool MC::isSUSY ( const T & p )

inline

Definition at line 630 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTau() [1/2]

template<>

bool MC::isTau ( const int & p )

inline

Definition at line 216 of file HepMCHelpers.h.

isTau() [2/2]

template<class T>

bool MC::isTau ( const T & p )

inline

Definition at line 215 of file HepMCHelpers.h.

isTechnicolor() [1/3]

template<>

bool MC::isTechnicolor ( const DecodedPID & p )

inline

Definition at line 533 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTechnicolor() [2/3]

template<>

bool MC::isTechnicolor ( const int & p )

inline

Definition at line 539 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTechnicolor() [3/3]

template<class T>

bool MC::isTechnicolor ( const T & p )

inline

PDG rule 11e Technicolor states have n = 3, with technifermions treated like ordinary fermions.

States which are ordinary color singlets have n_r = 0. Color octets have n_r = 1. If a state has non-trivial quantum numbers under the topcolor groups SU(3)1×SU(3)2, the quantum numbers are specified by tech, ij, where i and j are 1 or 2. nLis then 2i+j. The coloron V8, is a heavy gluon color octet and thus is 3100021

Definition at line 531 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTetraquark() [1/3]

template<>

bool MC::isTetraquark ( const DecodedPID & p )

inline

Definition at line 333 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTetraquark() [2/3]

template<>

bool MC::isTetraquark ( const int & p )

inline

Definition at line 340 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTetraquark() [3/3]

template<class T>

bool MC::isTetraquark ( const T & p )

inline

PDG rule 14 The 9-digit tetra-quark codes are ±1nrnLnq1nq20nq3nq4nJ.

For the particle q1q2 is a diquark and ̄q3 ̄q4 an antidiquark, sorted such that nq1≥nq2, nq3≥nq4, nq1≥nq3, and nq2≥nq4 if nq1=nq3. For the antiparticle, given with a negative sign, ̄q1 ̄q2 is an antidiquark and q3q4 a diquark, with the same sorting except that either nq1>nq3 or nq2>nq4 (so that flavour-diagonal states are particles). The nr, nL, and nJ numbers have the same meaning as for ordinary hadrons. APID: states with fourth generation quarks are not tetraquarks

Definition at line 332 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTop() [1/2]

template<>

bool MC::isTop ( const int & p )

inline

Definition at line 193 of file HepMCHelpers.h.

isTop() [2/2]

template<class T>

bool MC::isTop ( const T & p )

inline

Definition at line 192 of file HepMCHelpers.h.

isTopBaryon()

template<class T>

bool MC::isTopBaryon ( const T & p )

inline

Definition at line 943 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTopHadron()

template<class T>

bool MC::isTopHadron ( const T & p )

inline

Definition at line 920 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTopMeson()

template<class T>

bool MC::isTopMeson ( const T & p )

inline

Definition at line 927 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTrajectory() [1/2]

template<>

bool MC::isTrajectory ( const int & p )

inline

Definition at line 367 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTrajectory() [2/2]

template<class T>

bool MC::isTrajectory ( const T & p )

inline

PDG rule 8: The pomeron and odderon trajectories and a generic reggeon trajectory of states in QCD areassigned codes 990, 9990, and 110 respectively.

Definition at line 366 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTransportable() [1/3]

template<>

bool MC::isTransportable ( const DecodedPID & p )

inline

Definition at line 881 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTransportable() [2/3]

template<>

bool MC::isTransportable ( const int & p )

inline

Definition at line 882 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isTransportable() [3/3]

template<class T>

bool MC::isTransportable ( const T & p )

inline

Definition at line 880 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isValid() [1/3]

template<>

bool MC::isValid ( const DecodedPID & p )

inline

Definition at line 886 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isValid() [2/3]

template<>

bool MC::isValid ( const int & p )

inline

Definition at line 891 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isValid() [3/3]

template<class T>

bool MC::isValid ( const T & p )

inline

Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.

Definition at line 885 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isW() [1/2]

template<>

bool MC::isW ( const int & p )

inline

Definition at line 390 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isW() [2/2]

template<class T>

bool MC::isW ( const T & p )

inline

Definition at line 389 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isWeaklyDecayingBHadron() [1/3]

template<>

bool MC::isWeaklyDecayingBHadron ( const DecodedPID & p )

inline

Definition at line 975 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isWeaklyDecayingBHadron() [2/3]

template<>

bool MC::isWeaklyDecayingBHadron ( const int & p )

inline

Definition at line 950 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isWeaklyDecayingBHadron() [3/3]

template<class T>

bool MC::isWeaklyDecayingBHadron ( const T & p )

inline

Definition at line 949 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isWeaklyDecayingCHadron() [1/3]

template<>

bool MC::isWeaklyDecayingCHadron ( const DecodedPID & p )

inline

Definition at line 999 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isWeaklyDecayingCHadron() [2/3]

template<>

bool MC::isWeaklyDecayingCHadron ( const int & p )

inline

Definition at line 985 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isWeaklyDecayingCHadron() [3/3]

template<class T>

bool MC::isWeaklyDecayingCHadron ( const T & p )

inline

Definition at line 984 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isZ() [1/2]

template<>

bool MC::isZ ( const int & p )

inline

Definition at line 387 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isZ() [2/2]

template<class T>

bool MC::isZ ( const T & p )

inline

Definition at line 386 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

isZeroEnergyPhoton()

template<class T>

bool MC::isZeroEnergyPhoton ( const T & p )

inline

Identify a photon with zero energy. Probably a workaround for a generator bug.

Definition at line 72 of file HepMCHelpers.h.

{ return isPhoton<T>(p) && p->e() == 0;}

leadingQuark() [1/3]

template<>

int MC::leadingQuark ( const DecodedPID & p )

inline

Definition at line 897 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

leadingQuark() [2/3]

template<>

int MC::leadingQuark ( const int & p )

inline

Definition at line 913 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

leadingQuark() [3/3]

template<class T>

int MC::leadingQuark ( const T & p )

inline

Definition at line 896 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

MeVToGeV()

void MC::MeVToGeV ( HepMC::GenEvent * evt )

inline

Definition at line 267 of file HepMCHelpers.h.

{ for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }

numberOfLambdas() [1/3]

template<>

int MC::numberOfLambdas ( const DecodedPID & p )

inline

Definition at line 832 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

numberOfLambdas() [2/3]

template<>

int MC::numberOfLambdas ( const int & p )

inline

Definition at line 837 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

numberOfLambdas() [3/3]

template<class T>

int MC::numberOfLambdas ( const T & p )

inline

Definition at line 831 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

numberOfProtons() [1/3]

template<>

int MC::numberOfProtons ( const DecodedPID & p )

inline

Definition at line 841 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

numberOfProtons() [2/3]

template<>

int MC::numberOfProtons ( const int & p )

inline

Definition at line 849 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

numberOfProtons() [3/3]

template<class T>

int MC::numberOfProtons ( const T & p )

inline

Definition at line 840 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

spin() [1/3]

template<>

double MC::spin ( const DecodedPID & p )

inline

Definition at line 1159 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

spin() [2/3]

template<>

double MC::spin ( const int & p )

inline

Definition at line 1160 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

spin() [3/3]

template<class T>

double MC::spin ( const T & p )

inline

Definition at line 1158 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

spin2() [1/3]

template<>

int MC::spin2 ( const DecodedPID & p )

inline

Definition at line 1119 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

spin2() [2/3]

template<>

int MC::spin2 ( const int & p )

inline

Definition at line 1156 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

spin2() [3/3]

template<class T>

int MC::spin2 ( const T & p )

inline

Definition at line 1118 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

strangeness() [1/3]

template<>

int MC::strangeness ( const DecodedPID & p )

inline

Definition at line 794 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

strangeness() [2/3]

template<>

int MC::strangeness ( const int & p )

inline

Definition at line 828 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

strangeness() [3/3]

template<class T>

int MC::strangeness ( const T & p )

inline

Definition at line 793 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

threeCharge()

template<class T>

double MC::threeCharge ( const T & p )

inline

Definition at line 1010 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

Variable Documentation

ARGON

const int MC::ARGON = 1000180400

static

Definition at line 146 of file HepMCHelpers.h.

B0

const int MC::B0 = 511

static

Definition at line 123 of file HepMCHelpers.h.

BCPLUS

const int MC::BCPLUS = 541

static

Definition at line 124 of file HepMCHelpers.h.

BORON

const int MC::BORON = 1000050110

static

Definition at line 150 of file HepMCHelpers.h.

BPRIME

const int MC::BPRIME = 7

static

Definition at line 71 of file HepMCHelpers.h.

BQUARK

const int MC::BQUARK = 5

static

Definition at line 69 of file HepMCHelpers.h.

CALCIUM

const int MC::CALCIUM = 1000200400

static

Definition at line 145 of file HepMCHelpers.h.

COMPOSITEGLUON

const int MC::COMPOSITEGLUON = 9

static

Definition at line 87 of file HepMCHelpers.h.

CQUARK

const int MC::CQUARK = 4

static

Definition at line 68 of file HepMCHelpers.h.

D0

const int MC::D0 = 421

static

Definition at line 120 of file HepMCHelpers.h.

DARKPHOTON

const int MC::DARKPHOTON = 60000

static

PDG Ids for Mavtop madgraph UFO model found under DarkX.

The mavtop is a vector-like top partner with coupling to a dark photon. Theory paper: https://arxiv.org/abs/1904.05893 Pheno paper: https://arxiv.org/pdf/2112.08425

Definition at line 107 of file HepMCHelpers.h.

double_spin

const std::array<int,TABLESIZE> MC::double_spin

static

Initial value:

                                    = {
  +0, +1, +1, +1, +1, +1, +1, +1, +1, +0,
  +0, +1, +1, +1, +1, +1, +1, +1, +1, +0,
  +2, +2, +2, +2, +2, +0, +0, +0, +0, +0,
  +0, +0, +2, +2, +2, +0, +0, +0, +0, +4,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +1, +2, +0, +2, +0, +1, +2, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0
}

Definition at line 51 of file HepMCHelpers.h.

                                                        { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}
 

DPLUS

const int MC::DPLUS = 411

static

Definition at line 118 of file HepMCHelpers.h.

DQUARK

const int MC::DQUARK = 1

static

Definition at line 65 of file HepMCHelpers.h.

DSPLUS

const int MC::DSPLUS = 431

static

Definition at line 121 of file HepMCHelpers.h.

DSTAR

const int MC::DSTAR = 413

static

Definition at line 119 of file HepMCHelpers.h.

ELECTRON

const int MC::ELECTRON = 11

static

Definition at line 75 of file HepMCHelpers.h.

GEANTINO0

const int MC::GEANTINO0 = 999

static

Definition at line 166 of file HepMCHelpers.h.

GEANTINOPLUS

const int MC::GEANTINOPLUS = 998

static

PDG rule 10: Codes 81–100 are reserved for generator-specific pseudoparticles and concepts.

Codes 901–930, 1901–1930, 2901–2930, and 3901–3930 are for additional components of Standard Modelparton distribution functions, where the latter three ranges are intended to distinguish left/right/ longitudinal components. Codes 998 and 999 are reserved for GEANT tracking purposes.

Definition at line 165 of file HepMCHelpers.h.

GLUON

const int MC::GLUON = 21

static

Definition at line 85 of file HepMCHelpers.h.

GRAVITON

const int MC::GRAVITON = 39

static

Definition at line 99 of file HepMCHelpers.h.

HELIUM

const int MC::HELIUM = 1000020040

static

Definition at line 151 of file HepMCHelpers.h.

HIGGS2

const int MC::HIGGS2 = 35

static

Definition at line 95 of file HepMCHelpers.h.

HIGGS3

const int MC::HIGGS3 = 36

static

Definition at line 96 of file HepMCHelpers.h.

HIGGS4

const int MC::HIGGS4 = 40

static

Definition at line 100 of file HepMCHelpers.h.

HIGGSBOSON

const int MC::HIGGSBOSON = 25

static

Definition at line 91 of file HepMCHelpers.h.

HIGGSPLUS

const int MC::HIGGSPLUS = 37

static

Definition at line 97 of file HepMCHelpers.h.

HIGGSPLUSPLUS

const int MC::HIGGSPLUSPLUS = 38

static

Definition at line 98 of file HepMCHelpers.h.

INDIUM

const int MC::INDIUM = 1000491150

static

Definition at line 143 of file HepMCHelpers.h.

is_strange

const std::array<int,10> MC::is_strange

static

Initial value:

                                 = {
+0, +0, +0, -1, +0, +0, +0, +0, +0, +0 }

Definition at line 791 of file HepMCHelpers.h.

{
 namespace Pythia8
 {
  template <class T> inline bool isConditionA(const T& p) { return p->status() == 62 || p->status() == 52 || p->status() == 21 || p->status() == 22;}
 
  template <class T> inline bool isConditionB(const T& p) { return p->status() == 23;}
 
  template <class T> inline bool isConditionC(const T& p) { return p->status() > 30 && p->status() < 40;}
 }
 
#include "AtlasPID.h"

  template <class T> inline bool isInteracting(const T& p) { return isStrongInteracting<T>(p) || isEMInteracting<T>(p) || isGeantino<T>(p); }

  template <class T> inline bool isChargedNonShowering(const T& p) { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}

  template <class T> inline bool isFinalState(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1 && !p->end_vertex();}

  template <class T> inline bool isPhysical(const T& p) { return isStable<T>(p) || isDecayed<T>(p); }

  template <class T> inline bool isGenStable(const T& p) { return isStable<T>(p) && !HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimStable(const T& p) { return  isStable<T>(p) &&  !p->end_vertex() && HepMC::is_simulation_particle<T>(p);}

  template <class T> inline bool isSimInteracting(const T& p) { return isGenStable<T>(p) && isInteracting<T>(p);}

  template <class T> inline bool isStableOrSimDecayed(const T& p) {
    const auto vertex = p->end_vertex();
    return ( isStable<T>(p) || (isDecayed<T>(p) && (!vertex || HepMC::is_simulation_vertex(vertex))));
  }

  template <class T> inline bool isZeroEnergyPhoton(const T&  p) { return isPhoton<T>(p) && p->e() == 0;}

  template <class T> inline bool isSpecialNonInteracting(const T& p) {
    const int apid = std::abs(p->pdg_id());
    if (apid == NU_E || apid == NU_MU || apid == NU_TAU) return true; //< neutrinos
    if (apid == 1000022 || apid == 1000024 || apid == 5100022) return true; // SUSY & KK photon and Z partners
    if (apid == GRAVITON || apid == 1000039 || apid == 5000039) return true; //< gravitons: standard, SUSY and KK
    if (apid == 9000001 || apid == 9000002 || apid == 9000003 || apid == 9000004 || apid == 9000005 || apid == 9000006) return true; //< exotic particles from monotop model
    return false;
  }


  template <class T> T findMother(T thePart) {
    auto partOriVert = thePart->production_vertex();
    if (!partOriVert) return nullptr;
 
    long partPDG = thePart->pdg_id();
    long MotherPDG(0);
 
    auto MothOriVert = partOriVert;
    MothOriVert = nullptr;
    T theMoth(nullptr);
 
    size_t itr = 0;
    do {
      if (itr != 0) partOriVert = MothOriVert;
      for ( const auto& p : partOriVert->particles_in() ) {
        theMoth = p;
        if (!theMoth) continue;
        MotherPDG = theMoth->pdg_id();
        MothOriVert = theMoth->production_vertex();
        if (MotherPDG == partPDG) break;
      }
      itr++;
      if (itr > 100) {
        break;
      }
    } while (MothOriVert != nullptr && MotherPDG == partPDG && !HepMC::is_simulation_particle(thePart) &&
           MothOriVert != partOriVert);
    return theMoth;
  }


  template <class C, class T> T findMatching(C TruthContainer, T p) {
    T ptrPart = nullptr;
    if (!p) return ptrPart;
    if constexpr (std::is_pointer_v<C> || HepMC::is_smart_ptr_v<C>){ //C is ptr
      for (T truthParticle : *TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    else {
      for (T truthParticle : TruthContainer) {
        if (HepMC::is_sim_descendant(p,truthParticle)) {
          ptrPart = truthParticle;
          break;
        }
      }
    }
    return ptrPart;
  }

  template <class T> void findParticleAncestors(T thePart, std::set<T>& allancestors) {
    auto prodVtx = thePart->production_vertex();
    if (!prodVtx) return;
    for (const auto& theMother: prodVtx->particles_in()) {
      if (!theMother) continue;
      allancestors.insert(theMother);
      findParticleAncestors(theMother, allancestors);
    }
  }


  template <class T> void findParticleStableDescendants(T thePart, std::set<T>& allstabledescendants) {
    auto endVtx = thePart->end_vertex();
    if (!endVtx) return;
    for (const auto& theDaughter: endVtx->particles_out()) {
      if (!theDaughter) continue;
      if (isStable(theDaughter) && !HepMC::is_simulation_particle(theDaughter)) {
         allstabledescendants.insert(theDaughter);
      }
      findParticleStableDescendants(theDaughter, allstabledescendants);
    }
  }


  template <class T> bool isHardScatteringVertex(T pVert) {
    if (pVert == nullptr) return false;
    T pV = pVert;
    int numOfPartIn(0);
    int pdg(0);
 
    do {
      pVert = pV;
      auto incoming = pVert->particles_in();
      numOfPartIn = incoming.size();
      pdg = numOfPartIn && incoming.front() != nullptr ? incoming.front()->pdg_id() : 0;
      pV = numOfPartIn && incoming.front() != nullptr ? incoming.front()->production_vertex() : nullptr;
 
    } while (numOfPartIn == 1 && (std::abs(pdg) < 81 || std::abs(pdg) > 100) && pV != nullptr);
 
    if (numOfPartIn == 2) {
      auto incoming = pVert->particles_in();
      if (incoming.at(0) && incoming.at(1) && (std::abs(incoming.at(0)->pdg_id()) < 7 || incoming.at(0)->pdg_id() == 21) && (std::abs(incoming.at(1)->pdg_id()) < 7 || incoming.at(1)->pdg_id() == 21)) return true;
    }
    return false;
}


    template <class T, class U> bool isFromHadron(T p, U hadron, bool &fromTau, bool &fromBSM) {
    if (isHadron(p)&&!isBeam(p))  return true; // trivial case
    auto vtx = p->production_vertex();
    if (!vtx)  return false;
    bool fromHad = false;
    for ( const auto& parent : vtx->particles_in() ) {
      if (!parent) continue;
      // should this really go into parton-level territory?
      // probably depends where BSM particles are being decayed
      fromBSM |= isBSM(parent);
      if (!isPhysical(parent))  return false;
      fromTau |= isTau(parent);
      if (isHadron(parent)&&!isBeam(parent)) {
        if (!hadron)  hadron = parent; // assumes linear hadron parentage
        return true;
      }
      fromHad |= isFromHadron(parent, hadron, fromTau, fromBSM);
    }
    return fromHad;
  }


  template <class T> auto findSimulatedEndVertex(T thePart) -> decltype(thePart->end_vertex()) {
     decltype(thePart->end_vertex()) EndVert = thePart->end_vertex();
     decltype(thePart->end_vertex()) pVert(nullptr);
    if (EndVert != nullptr) {
      do {
        bool samePart = false;
        pVert = nullptr;
        auto outgoing = EndVert->particles_out();
        auto incoming = EndVert->particles_in();
        for (const auto& itrDaug: outgoing) {
          if (!itrDaug) continue;
          if ((( HepMC::is_same_generator_particle(itrDaug,thePart)) ||
             // brem on generator level for tau
             (outgoing.size() == 1 && incoming.size() == 1 &&
              !HepMC::is_simulation_particle(itrDaug) && !HepMC::is_simulation_particle(thePart))) &&
            itrDaug->pdg_id() == thePart->pdg_id()) {
            samePart = true;
            pVert = itrDaug->end_vertex();
          }
        }
        if (samePart) EndVert = pVert;
      } while (pVert != nullptr && pVert != EndVert); // pVert!=EndVert to prevent Sherpa loop
    }
    return EndVert;
  }


  template <class V> auto findFinalStateParticles(V theVert) -> decltype(theVert->particles_out()) {
    if (!theVert) return {};
    decltype(theVert->particles_out()) finalStatePart;
    auto outgoing = theVert->particles_out();
    for (const auto& thePart: outgoing) {
      if (!thePart) continue;
      finalStatePart.push_back(thePart);
      if (isStable(thePart)) continue;
      V pVert = findSimulatedEndVertex(thePart);
      if (pVert == theVert) break; // to prevent Sherpa  loop
      if (pVert != nullptr) {
          auto  vecPart = findFinalStateParticles<V>(pVert);
          finalStatePart.insert(finalStatePart.end(),vecPart.begin(),vecPart.end());
      }
    }
    return finalStatePart;
  }
#if !defined(XAOD_ANALYSIS)
#include "AtlasHepMC/GenEvent.h"
inline void GeVToMeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1000); p->set_generated_mass(1000* p->generated_mass());}}
inline void MeVToGeV(HepMC::GenEvent* evt) { for (auto& p: evt->particles()) { p->set_momentum(p->momentum()*1.0/1000); p->set_generated_mass(1.0/1000* p->generated_mass());} }
 
#endif
}
#endif

JPSI

const int MC::JPSI = 443

static

Definition at line 122 of file HepMCHelpers.h.

K0

const int MC::K0 = 311

static

Definition at line 116 of file HepMCHelpers.h.

K0L

const int MC::K0L = 130

static

Definition at line 113 of file HepMCHelpers.h.

K0S

const int MC::K0S = 310

static

Definition at line 115 of file HepMCHelpers.h.

KPLUS

const int MC::KPLUS = 321

static

Definition at line 117 of file HepMCHelpers.h.

KRYPTON

const int MC::KRYPTON = 1000360840

static

Definition at line 144 of file HepMCHelpers.h.

LAMBDA0

const int MC::LAMBDA0 = 3122

static

Definition at line 127 of file HepMCHelpers.h.

LAMBDAB0

const int MC::LAMBDAB0 = 5122

static

Definition at line 129 of file HepMCHelpers.h.

LAMBDACPLUS

const int MC::LAMBDACPLUS = 4122

static

Definition at line 128 of file HepMCHelpers.h.

LEAD

const int MC::LEAD = 1000822080

static

Definition at line 142 of file HepMCHelpers.h.

LEPTOQUARK

const int MC::LEPTOQUARK = 42

static

Definition at line 101 of file HepMCHelpers.h.

LPRIME

const int MC::LPRIME = 17

static

Definition at line 82 of file HepMCHelpers.h.

MAGNESIUM

const int MC::MAGNESIUM = 1000120240

static

Definition at line 147 of file HepMCHelpers.h.

MAVTOP

const int MC::MAVTOP = 60001

static

Definition at line 108 of file HepMCHelpers.h.

MUON

const int MC::MUON = 13

static

Definition at line 78 of file HepMCHelpers.h.

NEON

const int MC::NEON = 1000100200

static

Definition at line 148 of file HepMCHelpers.h.

NEUTRON

const int MC::NEUTRON = 2112

static

Definition at line 126 of file HepMCHelpers.h.

NU_E

const int MC::NU_E = 12

static

Definition at line 77 of file HepMCHelpers.h.

NU_MU

const int MC::NU_MU = 14

static

Definition at line 79 of file HepMCHelpers.h.

NU_TAU

const int MC::NU_TAU = 16

static

Definition at line 81 of file HepMCHelpers.h.

NUPRIME

const int MC::NUPRIME = 18

static

Definition at line 83 of file HepMCHelpers.h.

ODDERON

const int MC::ODDERON = 9990

static

Definition at line 157 of file HepMCHelpers.h.

OXYGEN

const int MC::OXYGEN = 1000080160

static

Definition at line 149 of file HepMCHelpers.h.

PHOTON

const int MC::PHOTON = 22

static

Definition at line 88 of file HepMCHelpers.h.

PI0

const int MC::PI0 = 111

static

Definition at line 112 of file HepMCHelpers.h.

PIMINUS

const int MC::PIMINUS = -PIPLUS

static

Definition at line 111 of file HepMCHelpers.h.

PIPLUS

const int MC::PIPLUS = 211

static

Definition at line 110 of file HepMCHelpers.h.

POMERON

const int MC::POMERON = 990

static

PDG rule 8: The pomeron and odderon trajectories and a generic reggeon trajectory of states in QCD areassigned codes 990, 9990, and 110 respectively.

Definition at line 156 of file HepMCHelpers.h.

POSITRON

const int MC::POSITRON = -ELECTRON

static

Definition at line 76 of file HepMCHelpers.h.

PROTON

const int MC::PROTON = 2212

static

Definition at line 125 of file HepMCHelpers.h.

PSI2S

const int MC::PSI2S = 20443

static

Definition at line 130 of file HepMCHelpers.h.

QUARK_LIMIT

const int MC::QUARK_LIMIT = BPRIME

static

Definition at line 73 of file HepMCHelpers.h.

REGGEON

const int MC::REGGEON = 110

static

Definition at line 158 of file HepMCHelpers.h.

RH_NU_E

const int MC::RH_NU_E = 9900012

static

PDG Rule 12: Generator defined PDG ID values for right handed neutrinos and corresponding W+ boson from a Left-Right symmetric Standard Model extension.

(Defined for some MadGraph+Pythia8 samples and referenced in MCTruthClassifierGen.cxx)

Definition at line 137 of file HepMCHelpers.h.

RH_NU_MU

const int MC::RH_NU_MU = 9900014

static

Definition at line 138 of file HepMCHelpers.h.

RH_NU_TAU

const int MC::RH_NU_TAU = 9900016

static

Definition at line 139 of file HepMCHelpers.h.

SQUARK

const int MC::SQUARK = 3

static

Definition at line 67 of file HepMCHelpers.h.

TABLESIZE

const int MC::TABLESIZE = 100

static

Definition at line 35 of file HepMCHelpers.h.

TAU

const int MC::TAU = 15

static

Definition at line 80 of file HepMCHelpers.h.

TPRIME

const int MC::TPRIME = 8

static

Definition at line 72 of file HepMCHelpers.h.

TQUARK

const int MC::TQUARK = 6

static

Definition at line 70 of file HepMCHelpers.h.

triple_charge

const std::array<int,TABLESIZE> MC::triple_charge

static

Initial value:

                                      = {
  +0, -1, +2, -1, +2, -1, +2, -1, +2, +0,
  +0, -3, +0, -3, +0, -3, +0, -3, +0, +0,
  +0, +0, +0, +0, +3, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +3, +0, +0, +3, +6, +0,
  +0, +0, -1, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0,
  +0, +0, +0, +0, +0, +0, +0, +0, +0, +0
}

Definition at line 36 of file HepMCHelpers.h.

                                                                   { return (isMuon<T>(p) || isSUSY<T>(p)); }

  template <class T> inline bool isBeam(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 4;}

  template <class T> inline bool isDecayed(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 2;}

  template <class T> inline bool isStable(const T& p) { return HepMC::status(p)%HepMC::SIM_STATUS_THRESHOLD == 1;}
 

UQUARK

const int MC::UQUARK = 2

static

Definition at line 66 of file HepMCHelpers.h.

WBOSON_LRSM

const int MC::WBOSON_LRSM = 9900024

static

Definition at line 140 of file HepMCHelpers.h.

WPLUSBOSON

const int MC::WPLUSBOSON = 24

static

Definition at line 90 of file HepMCHelpers.h.

WPLUSPRIME

const int MC::WPLUSPRIME = 34

static

Definition at line 94 of file HepMCHelpers.h.

Z0BOSON

const int MC::Z0BOSON = 23

static

Definition at line 89 of file HepMCHelpers.h.

ZDBLPRIME

const int MC::ZDBLPRIME = 33

static

Definition at line 93 of file HepMCHelpers.h.

ZPRIME

const int MC::ZPRIME = 32

static

Definition at line 92 of file HepMCHelpers.h.