AtlasPID.h File Reference

#include <vector>
#include <cmath>
#include <algorithm>
#include <array>
#include <cstdlib>

Include dependency graph for AtlasPID.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

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

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)

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 baryonNumber ( const DecodedPID & p )

inline

Definition at line 780 of file AtlasPID.h.

{ return static_cast<double>(baryonNumber3(p))/3.0;}

baryonNumber() [2/3]

template<>

double baryonNumber ( const int & p )

inline

Definition at line 781 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p);  return static_cast<double>(baryonNumber3(value_digits))/3.0;}

baryonNumber() [3/3]

template<class T>

double baryonNumber ( const T & p )

inline

Definition at line 779 of file AtlasPID.h.

{return baryonNumber(p->pdg_id());}

baryonNumber3() [1/3]

template<>

int baryonNumber3 ( const DecodedPID & p )

inline

Definition at line 755 of file AtlasPID.h.

                                                         {
  if (isQuark(p.pid())) { return (p.pid() > 0) ? 1 : - 1;}
  if (isDiquark(p)) { return (p.pid() > 0) ? 2 : -2; }
  if (isMeson(p) || isTetraquark(p)) { return 0; }
  if (isBaryon(p) || isPentaquark(p)){ return (p.pid() > 0) ? 3 : -3; }
  if (isNucleus(p)) {
    const int result = 3*p(8) + 30*p(7) + 300*p(6);
    return (p.pid() > 0) ? result : -result;
  }
  if (isSUSY(p)) {
    auto pp = p.shift(1);
    if (pp.ndigits() < 3 ) { return baryonNumber3(pp); } // super-partners of fundamental particles
    if (pp(0) == COMPOSITEGLUON) {
      if (pp(1) == COMPOSITEGLUON) { return 0; } // R-Glueballs
      if ( pp.ndigits() == 4 ) { return 0; }  // states with gluino-quark-antiquark
      if ( pp.ndigits() == 5) { return (p.pid() > 0) ? 3 : -3; } // states with gluino-quark-quark-quark
    }
    if (pp.ndigits() == 3) { return 0; } // squark-antiquark
    if (pp.ndigits() == 4) { return (p.pid() > 0) ? 3 : -3; } // states with squark-quark-quark
  }
  return 0;
}

baryonNumber3() [2/3]

template<>

int baryonNumber3 ( const int & p )

inline

Definition at line 777 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return baryonNumber3(value_digits);}

baryonNumber3() [3/3]

template<class T>

int baryonNumber3 ( const T & p )

inline

Definition at line 754 of file AtlasPID.h.

{return baryonNumber3(p->pdg_id());}

charge()

template<class T>

double charge ( const T & p )

inline

Definition at line 1003 of file AtlasPID.h.

                                                    {
  if (isGenericMultichargedParticle(p)) // BSM multi-charged particles might have a fractional charge that's not a multiple of 1/3
    return fractionalCharge(p);
  else
    return 1.0*charge3(p)/3.0;
}

charge3() [1/3]

template<>

int 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 1013 of file AtlasPID.h.

                                                    {
  auto ap = std::abs(p.pid());
  if (ap < TABLESIZE ) return p.pid() > 0 ? triple_charge.at(ap) : -triple_charge.at(ap);
  if (ap == K0) return 0;
  if (ap == GEANTINO0) return 0;
  if (ap == GEANTINOPLUS) return p.pid() > 0 ? 3 : -3;
  if (ap == MAVTOP) return p.pid() > 0 ? 2 : -2;
  size_t nq = 0;
  int sign = 1;
  int signmult = 1;
  int result=0;
  bool classified = false;
  if (!classified && isMeson(p)) { classified = true; nq = 2; if ((*(p.second.rbegin()+2)) == 2||(*(p.second.rbegin()+2)) == 4 ) { sign=-1;} signmult =-1; }
  if (!classified && isDiquark(p)) {return triple_charge.at(p(0))+triple_charge.at(p(1)); }
  if (!classified && isBaryon(p)) { classified = true; nq = 3; }
  if (!classified && isTetraquark(p)){ return triple_charge.at(p(3)) + triple_charge.at(p(4)) - triple_charge.at(p(6)) - triple_charge.at(p(7)); }
  if (!classified && isPentaquark(p)){ return triple_charge.at(p(3)) + triple_charge.at(p(4)) + triple_charge.at(p(5)) + triple_charge.at(p(6)) - triple_charge.at(p(7)); }
  if (!classified && isNucleus(p)) { return 3*numberOfProtons(p);}
  if (!classified && isSUSY(p)) {
    nq = 0;
    auto pp = p.shift(1);
    if (pp.ndigits() < 3 ) { return charge3(pp); } // super-partners of fundamental particles
    if (pp(0) == COMPOSITEGLUON) {
      if (pp(1) == COMPOSITEGLUON) { return 0; } // R-Glueballs
      if ( pp.ndigits() == 4 || pp.ndigits() == 5) {
        pp = pp.shift(1); // Remove gluino
      }
    }
    if (pp.ndigits() == 3) { classified = true; nq = 2; if (p.last()%2==0) {sign = -1;} signmult = -1; } // states with squark-antiquark or quark-anti-quark
    if (pp.ndigits() == 4) { classified = true; nq = 3; } // states with squark-quark-quark or quark-quark-quark
  }
  if (!classified && isHiddenValley(p)) { // Hidden Valley particles
    auto pp = p.shift(2);
    if (!classified && isMeson(pp)) { classified = true; nq = 2; if ((*(pp.second.rbegin()+2)) == 2||(*(pp.second.rbegin()+2)) == 4 ) { sign=-1;} signmult =-1; }
    if (!classified && isDiquark(pp)) {return triple_charge.at(pp(0))+triple_charge.at(pp(1)); }
    if (!classified && isBaryon(pp)) { classified = true; nq = 3; }
  }
  if (!classified && isExcited(p)) { //Excited/composite leptons/quarks
    auto pp = p.shift(2);
    auto ap = std::abs(pp.pid());
    if (ap < TABLESIZE ) return pp.pid() > 0 ? triple_charge.at(ap) : -triple_charge.at(ap);
  }
  if (!classified && isKK(p)) { // Kaluza-Klein particles
    auto pp = p.shift(2);
    auto ap = std::abs(pp.pid());
    if (ap < TABLESIZE ) return pp.pid() > 0 ? triple_charge.at(ap) : -triple_charge.at(ap);
 
  }
  if (!classified && isDM(p.pid())) { //Dark Matter Particles
    if (p.ndigits() == 7){ // Determining the charges for the more elaborate, 7-digit DM codes
      auto pp = p.shift(3); // The first two digits indicate the particle is DM, the third indicates left/right-handedness (see 11(j))
      auto ap = std::abs(pp.pid());
      if (ap < TABLESIZE ) return pp.pid() > 0 ? triple_charge.at(ap) : -triple_charge.at(ap);
    }else if (std::abs(p.pid()) < TABLESIZE) return p.pid() > 0 ? triple_charge.at(ap) : -triple_charge.at(ap);  // Just to make sure the correct charge is returned for DM 51-60
  }
  if (!classified && isMonopole(p)) {
    result = 3*(p(3)*100 + p(4)*10 + p(5));
    return ( (p.pid() > 0 && p(2) == 1) ||  (p.pid() < 0 && p(2) == 2) ) ? result : -result;
  }
  if (!classified && isGenericMultichargedParticle(p)) {
    double abs_charge = 0.0;
    if (p(0) == 1) abs_charge = p(3)*100. + p(4)*10. + p(5)*1 + p(6)*0.1; // multi-charged particle PDG ID is +/-100XXXY0, where the charge is XXX.Y
    if (p(0) == 2) abs_charge = (p(3)*10. + p(4))/(p(5)*10.0 + p(6)); // multi-charged particle PDG ID is +/-200XXYY0, where the charge is XX/YY
    int abs_threecharge = static_cast<int>(std::round(abs_charge * 3.)); // the multi-charged particles might have a fractional charge that's not a multiple of 1/3, in that case round to the closest multiple of 1/3 for charge3 and threecharge
    return p.pid() > 0 ? abs_threecharge : -1 * abs_threecharge;
  }
  for (auto r = p.second.rbegin() + 1; r != p.second.rbegin() + 1 + nq; ++r) {
    result += triple_charge.at(*r)*sign;
    sign*=signmult;
  }
  return p.pid() > 0 ? result : -result;
}

charge3() [2/3]

template<>

int charge3 ( const int & p )

inline

Definition at line 1087 of file AtlasPID.h.

                                            {
  int ap = std::abs(p);
  if (ap < TABLESIZE) return p > 0 ? triple_charge.at(ap):-triple_charge.at(ap);
  auto value_digits = DecodedPID(p);
  return charge3(value_digits);
}

charge3() [3/3]

template<class T>

int charge3 ( const T & p )

inline

Definition at line 1001 of file AtlasPID.h.

{return charge3(p->pdg_id());}

containedQuarks() [1/3]

template<>

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

inline

Definition at line 1186 of file AtlasPID.h.

{ return containedQuarks(p.pid()); }

containedQuarks() [2/3]

template<>

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

inline

Definition at line 1164 of file AtlasPID.h.

                                                                {
  auto pp = DecodedPID(p);
  std::vector<int> quarks;
  if (isQuark(pp.pid())) { quarks.push_back(std::abs(pp.pid())); }
  else if (isDiquark(pp)) { quarks.push_back(pp(0)); quarks.push_back(pp(1)); }
  else if (isMeson(pp)) { quarks.push_back(*(pp.second.rbegin() + 1)); quarks.push_back(*(pp.second.rbegin()+2)); }
  else if (isBaryon(pp)) { for (size_t digit = 1; digit < 4; ++digit) { quarks.push_back(*(pp.second.rbegin() + digit)); } }
  else if (isTetraquark(pp)) { for (size_t digit = 1; digit < 5; ++digit) { quarks.push_back(*(pp.second.rbegin() + digit)); } }
  else if (isPentaquark(pp)) { for (size_t digit = 1; digit < 6; ++digit) { quarks.push_back(*(pp.second.rbegin() + digit)); } }
  else if (isNucleus(pp)) { const int A = std::abs(baryonNumber3(pp)/3); const int Z = std::abs(numberOfProtons(pp)); const int L = std::abs(numberOfLambdas(pp));
    const int n_uquarks = A + Z; const int n_dquarks = 2*A - Z - L; const int n_squarks = L;
    quarks.reserve(3*A); quarks.insert(quarks.end(), n_dquarks, 1); quarks.insert(quarks.end(), n_uquarks, 2); quarks.insert(quarks.end(), n_squarks, 3); }
  else if (isSUSY(pp)) { // APID SUSY case
    pp = pp.shift(1);
    if ( pp.ndigits() > 1 ) { // skip squarks
      if ( pp.ndigits() == 3 ) { pp = DecodedPID(pp(1)); } // Handle ~q qbar pairs
      if ( pp.ndigits()  > 3 ) { pp = pp.shift(1); } // Drop gluinos and squarks
      return containedQuarks(pp.pid());
    }
  }
  return quarks;
}

containedQuarks() [3/3]

template<class T>

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

inline

Definition at line 1163 of file AtlasPID.h.

{ return containedQuarks(p->pdg_id()); }

fractionalCharge() [1/3]

template<>

double fractionalCharge ( const DecodedPID & p )

inline

Definition at line 1100 of file AtlasPID.h.

                                                                {
  if(!isGenericMultichargedParticle(p)) return 1.0*charge3(p)/3.0; // this method is written for multi-charged particles, still make sure other cases are handled properly
  double abs_charge = 0;
  if (p(0) == 1) abs_charge = p(3)*100. + p(4)*10. + p(5)*1 + p(6)*0.1; // multi-charged particle PDG ID is +/-100XXXY0, where the charge is XXX.Y
  if (p(0) == 2) abs_charge = (p(3)*10. + p(4))/(p(5)*10.0 + p(6)); // multi-charged particle PDG ID is +/-200XXYY0, where the charge is XX/YY
  return p.pid() > 0 ? abs_charge : -1 * abs_charge;
}

fractionalCharge() [2/3]

template<>

double fractionalCharge ( const int & p )

inline

Definition at line 1107 of file AtlasPID.h.

{auto value_digits = DecodedPID(p); return fractionalCharge(value_digits);}

fractionalCharge() [3/3]

template<class T>

double fractionalCharge ( const T & p )

inline

Definition at line 1002 of file AtlasPID.h.

{return fractionalCharge(p->pdg_id());}

hasBottom()

template<class T>

bool hasBottom ( const T & p )

inline

Definition at line 744 of file AtlasPID.h.

{ return  hasQuark(p,BQUARK); }

hasCharm()

template<class T>

bool hasCharm ( const T & p )

inline

Definition at line 743 of file AtlasPID.h.

{ return  hasQuark(p,CQUARK); }

hasQuark() [1/3]

template<>

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

inline

Definition at line 722 of file AtlasPID.h.

                                                                   {
  if (isQuark(p.pid())) { return (std::abs(p.pid()) == q );}
  if (isMeson(p)) { return *(p.second.rbegin() + 1) == q ||*(p.second.rbegin()+2) ==q;}
  if (isDiquark(p)) { auto i = std::find(p.second.rbegin() + 2,p.second.rbegin()+4,q); return (i!=p.second.rbegin()+4);}
  if (isBaryon(p)) { auto i = std::find(p.second.rbegin() + 1,p.second.rbegin()+4,q); return (i!=p.second.rbegin()+4);}
  if (isTetraquark(p)) { auto i = std::find(p.second.rbegin() + 1,p.second.rbegin()+5,q); return (i!=p.second.rbegin()+5);}
  if (isPentaquark(p)) { auto i = std::find(p.second.rbegin() + 1,p.second.rbegin()+6,q); return (i!=p.second.rbegin()+6);}
  if (isNucleus(p) && std::abs(p.pid()) != PROTON) { return (q == 1 || q == 2 || (q==3 && p(2) > 0));}
  if (isSUSY(p)) { // APID SUSY case
    auto pp = p.shift(1);
    if ( pp.ndigits() == 1 ) { return false; } // Handle squarks
    if ( pp.ndigits() == 3 ) { return (pp(1) == q); } // Handle ~q qbar pairs
    if ( pp.ndigits() == 4 ) { return (pp(1) == q || pp(2) == q); } // Ignore gluinos and squarks
    if ( pp.ndigits() == 5 ) {  return (pp(1) == q || pp(2) == q || pp(3) == q); } // Ignore gluinos and squarks
    if ( pp.ndigits() > 5 ) { pp = pp.shift(1); } // Drop gluinos and squarks
    return hasQuark(pp, q); }
  return false;
}

hasQuark() [2/3]

template<>

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

inline

Definition at line 740 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return hasQuark(value_digits, q);}

hasQuark() [3/3]

template<class T>

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

inline

hasSquark() [1/3]

template<>

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

inline

Definition at line 617 of file AtlasPID.h.

                                                                    {
  auto pp = p.shift(1); return (
                                (isSquark(p) || isRHadron(p))
                                && pp.ndigits() != 2 // skip lepton and boson super-partners by vetoing ndigits==2
                                && pp(0) == q // After shifting, the first digit will always represent the squark in R-Hadron (and squark) PIDs
                                );
}

hasSquark() [2/3]

template<>

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

inline

Definition at line 624 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return hasSquark(value_digits, q);}

hasSquark() [3/3]

template<class T>

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

inline

Definition at line 616 of file AtlasPID.h.

{ return hasSquark(p->pdg_id(), q); }

hasStrange()

template<class T>

bool hasStrange ( const T & p )

inline

Definition at line 742 of file AtlasPID.h.

{ return  hasQuark(p,SQUARK); }

hasTop()

template<class T>

bool hasTop ( const T & p )

inline

Definition at line 745 of file AtlasPID.h.

{ return  hasQuark(p,TQUARK); }

isBaryon() [1/3]

template<>

bool isBaryon ( const DecodedPID & p )

inline

Definition at line 289 of file AtlasPID.h.

                                                     {
  if (p.ndigits() < 4 ) return false;
  if (p.max_digit(1,4) >= QUARK_LIMIT ) return false; // Ignore pdg_ids which would describe states including fourth generation quarks
  if (p.min_digit(1,4) == 0) return false; // Ignore pdg_ids with zero for nq1, nq2, nq3
  if (p.ndigits() == 4 && (p.last() == 2 || p.last() == 4|| p.last() == 6|| p.last() == 8) ) return true;
 
  if (p.ndigits() == 5 && p(0) == 1 &&  (p.last() == 2 || p.last() == 4) ) return true;
  if (p.ndigits() == 5 && p(0) == 3 &&  (p.last() == 2 || p.last() == 4) ) return true;
 
  if (p.ndigits() == 6 ) {
    if (p(0) == 1 && p(1) == 0 && p.last() == 2 ) return true;
    if (p(0) == 1 && p(1) == 0 && p.last() == 4 ) return true;
    if (p(0) == 1 && p(1) == 0 && p.last() == 6 ) return true;
    if (p(0) == 1 && p(1) == 1 && p.last() == 2 ) return true;
    if (p(0) == 1 && p(1) == 2 && p.last() == 4 ) return true;
 
    if (p(0) == 2 && p(1) == 0 && p.last() == 2 ) return true;
    if (p(0) == 2 && p(1) == 0 && p.last() == 4 ) return true;
    if (p(0) == 2 && p(1) == 0 && p.last() == 6 ) return true;
    if (p(0) == 2 && p(1) == 0 && p.last() == 8 ) return true;
    if (p(0) == 2 && p(1) == 1 && p.last() == 2 ) return true;
  }
 
  if (p.ndigits() == 5 ) {
    if (p(0) == 2 && p.last() == 2 ) return true;
    if (p(0) == 2 && p.last() == 4 ) return true;
    if (p(0) == 2 && p.last() == 6 ) return true;
    if (p(0) == 5 && p.last() == 2 ) return true;
    if (p(0) == 1 && p.last() == 6 ) return true;
    if (p(0) == 4 && p.last() == 2 ) return true;
  }
  return false;
}

isBaryon() [2/3]

template<>

bool isBaryon ( const int & p )

inline

Definition at line 322 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isBaryon(value_digits);}

isBaryon() [3/3]

template<class T>

bool isBaryon ( const T & p )

inline

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

Definition at line 288 of file AtlasPID.h.

{return isBaryon(p->pdg_id());}

isBBbarMeson() [1/3]

template<>

bool isBBbarMeson ( const DecodedPID & p )

inline

Definition at line 933 of file AtlasPID.h.

{ return leadingQuark(p) == BQUARK && isMeson(p) && (*(p.second.rbegin()+2)) == BQUARK && (*(p.second.rbegin()+1)) == BQUARK; }

isBBbarMeson() [2/3]

template<>

bool isBBbarMeson ( const int & p )

inline

Definition at line 934 of file AtlasPID.h.

{ return isBBbarMeson(DecodedPID(p)); }

isBBbarMeson() [3/3]

template<class T>

bool isBBbarMeson ( const T & p )

inline

Definition at line 932 of file AtlasPID.h.

{ return isBBbarMeson(p->pdg_id());}

isBoson() [1/3]

template<>

bool isBoson ( const DecodedPID & p )

inline

Definition at line 377 of file AtlasPID.h.

{ return isBoson(p.pid()); }

isBoson() [2/3]

template<>

bool isBoson ( const int & p )

inline

Definition at line 376 of file AtlasPID.h.

{ auto sp = std::abs(p); return sp > 20 && sp < 41; }

isBoson() [3/3]

template<class T>

bool 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 375 of file AtlasPID.h.

{return isBoson(p->pdg_id());}

isBottom() [1/2]

template<>

bool isBottom ( const int & p )

inline

Definition at line 189 of file AtlasPID.h.

{ return std::abs(p) == BQUARK;}

isBottom() [2/2]

template<class T>

bool isBottom ( const T & p )

inline

Definition at line 188 of file AtlasPID.h.

{return isBottom(p->pdg_id());}

isBottomBaryon()

template<class T>

bool isBottomBaryon ( const T & p )

inline

Definition at line 941 of file AtlasPID.h.

{ return  leadingQuark(p) == BQUARK && isBaryon(p); }

isBottomHadron()

template<class T>

bool isBottomHadron ( const T & p )

inline

Definition at line 918 of file AtlasPID.h.

{ return  leadingQuark(p) == BQUARK && isHadron(p); }

isBottomMeson()

template<class T>

bool isBottomMeson ( const T & p )

inline

Definition at line 925 of file AtlasPID.h.

{ return  leadingQuark(p) == BQUARK && isMeson(p); }

isBSM() [1/3]

template<>

bool isBSM ( const DecodedPID & p )

inline

Definition at line 853 of file AtlasPID.h.

                                                  {
  if (p.pid() == GRAVITON || std::abs(p.pid()) == MAVTOP || p.pid() == DARKPHOTON) return true;
  if (std::abs(p.pid()) > 16 && std::abs(p.pid()) < 19) return true;
  if (std::abs(p.pid()) > 31 && std::abs(p.pid()) < 39) return true;
  if (std::abs(p.pid()) > 39 && std::abs(p.pid()) < 81) return true;
  if (std::abs(p.pid()) > 6 && std::abs(p.pid()) < 9) return true;
  if (isSUSY(p)) return true;
  if (isNeutrinoRH(p.pid())) return true;
  if (isGenericMultichargedParticle(p)) return true;
  if (isTechnicolor(p)) return true;
  if (isExcited(p)) return true;
  if (isKK(p)) return true;
  if (isHiddenValley(p)) return true;
  if (isMonopole(p)) return true;
  if (isDM(p.pid())) return true;
  return false;
}

isBSM() [2/3]

template<>

bool isBSM ( const int & p )

inline

Definition at line 870 of file AtlasPID.h.

                                           {
  if (p == GRAVITON || std::abs(p) == MAVTOP || p == DARKPHOTON) return true;
  if (std::abs(p) > 16 && std::abs(p) < 19) return true;
  if (std::abs(p) > 31 && std::abs(p) < 38) return true;
  if (std::abs(p) > 39 && std::abs(p) < 81) return true;
  if (std::abs(p) > 6 && std::abs(p) < 9) return true;
  auto value_digits = DecodedPID(p); return isBSM(value_digits);
}

isBSM() [3/3]

template<class T>

bool isBSM ( const T & p )

inline

APID: graviton and all Higgs extensions are BSM.

Definition at line 852 of file AtlasPID.h.

{return isBSM(p->pdg_id());}

isCCbarMeson() [1/3]

template<>

bool isCCbarMeson ( const DecodedPID & p )

inline

Definition at line 929 of file AtlasPID.h.

{ return leadingQuark(p) == CQUARK && isMeson(p) && (*(p.second.rbegin()+2)) == CQUARK && (*(p.second.rbegin()+1)) == CQUARK; }

isCCbarMeson() [2/3]

template<>

bool isCCbarMeson ( const int & p )

inline

Definition at line 930 of file AtlasPID.h.

{ return isCCbarMeson(DecodedPID(p)); }

isCCbarMeson() [3/3]

template<class T>

bool isCCbarMeson ( const T & p )

inline

Definition at line 928 of file AtlasPID.h.

{ return isCCbarMeson(p->pdg_id());}

isCharged()

template<class T>

bool isCharged ( const T & p )

inline

Definition at line 1010 of file AtlasPID.h.

{ return charge3(p) != 0;}

isCharm() [1/2]

template<>

bool isCharm ( const int & p )

inline

Definition at line 186 of file AtlasPID.h.

{ return std::abs(p) == CQUARK;}

isCharm() [2/2]

template<class T>

bool isCharm ( const T & p )

inline

Definition at line 185 of file AtlasPID.h.

{return isCharm(p->pdg_id());}

isCharmBaryon()

template<class T>

bool isCharmBaryon ( const T & p )

inline

Definition at line 940 of file AtlasPID.h.

{ return  leadingQuark(p) == CQUARK && isBaryon(p); }

isCharmHadron()

template<class T>

bool isCharmHadron ( const T & p )

inline

Definition at line 917 of file AtlasPID.h.

{ return  leadingQuark(p) == CQUARK && isHadron(p); }

isCharmMeson()

template<class T>

bool isCharmMeson ( const T & p )

inline

Definition at line 924 of file AtlasPID.h.

{ return  leadingQuark(p) == CQUARK && isMeson(p); }

isChLepton() [1/2]

template<>

bool isChLepton ( const int & p )

inline

Definition at line 206 of file AtlasPID.h.

{ auto sp = std::abs(p); return sp >= ELECTRON && sp <= LPRIME && sp%2 == 1; }

isChLepton() [2/2]

template<class T>

bool isChLepton ( const T & p )

inline

APID: the fourth generation leptons are leptons.

Definition at line 205 of file AtlasPID.h.

{return isChLepton(p->pdg_id());}

isDiquark() [1/3]

template<>

bool isDiquark ( const DecodedPID & p )

inline

Definition at line 234 of file AtlasPID.h.

                                                      {
  if ( p.ndigits() == 4 && p(0) >= p(1) && p(1) !=0 && p(2) == 0 && (p.last() == 1 || p.last() == 3)
       && p.max_digit(2,4) < QUARK_LIMIT
       ) return true;
  return false;
}

isDiquark() [2/3]

template<>

bool isDiquark ( const int & p )

inline

Definition at line 240 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isDiquark(value_digits);}

isDiquark() [3/3]

template<class T>

bool 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 233 of file AtlasPID.h.

{return isDiquark(p->pdg_id());}

isDM() [1/2]

template<>

bool isDM ( const int & p )

inline

Definition at line 665 of file AtlasPID.h.

                                          {
  auto sp = std::abs(p);
  auto value_digits = DecodedPID(p);
  return (sp >= 51 && sp <= 60) || (value_digits.ndigits() == 7 && value_digits(0) == 5 && value_digits(1) == 9) || sp == DARKPHOTON; }

isDM() [2/2]

template<class T>

bool 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 664 of file AtlasPID.h.

{return isDM(p->pdg_id());}

isElectron() [1/2]

template<>

bool isElectron ( const int & p )

inline

Definition at line 209 of file AtlasPID.h.

{ return std::abs(p) == ELECTRON;}

isElectron() [2/2]

template<class T>

bool isElectron ( const T & p )

inline

Definition at line 208 of file AtlasPID.h.

{return isElectron(p->pdg_id());}

isEMInteracting() [1/2]

template<>

bool isEMInteracting ( const int & p )

inline

Definition at line 1111 of file AtlasPID.h.

{return (isPhoton(p) || isZ(p) || p == ZPRIME || p == ZDBLPRIME || std::abs(charge(p))>std::numeric_limits<double>::epsilon() || isMonopole(p));}

isEMInteracting() [2/2]

template<class T>

bool isEMInteracting ( const T & p )

inline

Definition at line 1110 of file AtlasPID.h.

{return isEMInteracting(p->pdg_id());}

isExcited() [1/3]

template<>

bool isExcited ( const DecodedPID & p )

inline

Definition at line 544 of file AtlasPID.h.

                                           {
  const auto& pp = (p.ndigits() == 7) ? p.shift(2) : DecodedPID(0);
  return (p.ndigits() == 7 && (p(0) == 4 && p(1) == 0) &&
          (isLepton(pp) || isQuark(pp)));
}

isExcited() [2/3]

template<>

bool isExcited ( const int & p )

inline

Definition at line 549 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isExcited(value_digits);}

isExcited() [3/3]

template<class T>

bool 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 542 of file AtlasPID.h.

{return isExcited(p->pdg_id());}

isFourthGeneration() [1/2]

template<>

bool isFourthGeneration ( const int & p )

inline

Definition at line 227 of file AtlasPID.h.

{return std::abs(p) == BPRIME || std::abs(p) == TPRIME || std::abs(p) == LPRIME || std::abs(p) == NUPRIME;}

isFourthGeneration() [2/2]

template<class T>

bool isFourthGeneration ( const T & p )

inline

Is this a 4th generation fermion?

APID: 4th generation fermions are not standard model particles

Definition at line 226 of file AtlasPID.h.

{return isFourthGeneration(p->pdg_id());}

isGaugino() [1/3]

template<>

bool isGaugino ( const DecodedPID & p )

inline

Definition at line 511 of file AtlasPID.h.

                                                      {
  auto pp = p.shift(1); return (p.ndigits() == 7 && p(0) == 1 && isBoson(pp.pid()));
}

isGaugino() [2/3]

template<>

bool isGaugino ( const int & p )

inline

Definition at line 514 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isGaugino(value_digits);}

isGaugino() [3/3]

template<class T>

bool isGaugino ( const T & p )

inline

Definition at line 510 of file AtlasPID.h.

{ return isGaugino(p->pdg_id()); }

isGeantino() [1/2]

template<>

bool isGeantino ( const int & p )

inline

Definition at line 444 of file AtlasPID.h.

{ return (std::abs(p) ==  GEANTINO0 || std::abs(p) ==  GEANTINOPLUS);}

isGeantino() [2/2]

template<class T>

bool isGeantino ( const T & p )

inline

Definition at line 443 of file AtlasPID.h.

{return isGeantino(p->pdg_id());}

isGenericMultichargedParticle() [1/3]

template<>

bool isGenericMultichargedParticle ( const DecodedPID & p )

inline

Definition at line 691 of file AtlasPID.h.

{return (p.ndigits() == 8 && (p(0) == 1 || p(0) == 2) && p(1) == 0 && p(2) == 0 && p(7) == 0);}

isGenericMultichargedParticle() [2/3]

template<>

bool isGenericMultichargedParticle ( const int & p )

inline

Definition at line 692 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isGenericMultichargedParticle(value_digits);}

isGenericMultichargedParticle() [3/3]

template<class T>

bool 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 690 of file AtlasPID.h.

{return isGenericMultichargedParticle(p->pdg_id());}

isGenSpecific() [1/2]

template<>

bool isGenSpecific ( const int & p )

inline

Definition at line 432 of file AtlasPID.h.

                                                   {
  int ap = std::abs(p);
  if (ap >= 81 && ap <= 100) return true;
  if (ap >= 901 && ap <= 930) return true;
  if (ap >= 998 && ap <= 999) return true;
  if (ap >= 1901 && ap <= 1930) return true;
  if (ap >= 2901 && ap <= 2930) return true;
  if (ap >= 3901 && ap <= 3930) return true;
  return false;
}

isGenSpecific() [2/2]

template<class T>

bool 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 431 of file AtlasPID.h.

{return isGenSpecific(p->pdg_id());}

isGlueball() [1/3]

template<>

bool isGlueball ( const DecodedPID & p )

inline

Definition at line 448 of file AtlasPID.h.

                                                        {
  if (p.ndigits() > 4) return false; // APID avoid classifying R-Glueballs as SM Glueballs
  return
    ( ( p.ndigits() == 3 && p(0) == COMPOSITEGLUON && p(1) == COMPOSITEGLUON && (p.last() == 1 || p.last() == 5) ) ||
      ( p.ndigits() == 4 && p(0) == COMPOSITEGLUON && p(1) == COMPOSITEGLUON && p(2) == COMPOSITEGLUON &&  (p.last() == 3 || p.last() == 7) )  );
}

isGlueball() [2/3]

template<>

bool isGlueball ( const int & p )

inline

Definition at line 454 of file AtlasPID.h.

{  auto value_digits = DecodedPID(p); return isGlueball(value_digits); }

isGlueball() [3/3]

template<class T>

bool isGlueball ( const T & p )

inline

APID: Definition of Glueballs: SM glueballs 99X (X=1,5), 999Y (Y=3,7).

Definition at line 447 of file AtlasPID.h.

{ return isGlueball(p->pdg_id()); }

isGluon() [1/2]

template<>

bool isGluon ( const int & p )

inline

Definition at line 380 of file AtlasPID.h.

{ return p == GLUON; }

isGluon() [2/2]

template<class T>

bool isGluon ( const T & p )

inline

Definition at line 379 of file AtlasPID.h.

{return isGluon(p->pdg_id());}

isGraviton() [1/2]

template<>

bool isGraviton ( const int & p )

inline

Definition at line 404 of file AtlasPID.h.

{ return p == GRAVITON; }

isGraviton() [2/2]

template<class T>

bool isGraviton ( const T & p )

inline

Definition at line 403 of file AtlasPID.h.

{return isGraviton(p->pdg_id());}

isHadron() [1/3]

template<>

bool isHadron ( const DecodedPID & p )

inline

Definition at line 358 of file AtlasPID.h.

{ return isMeson(p) || isBaryon(p) || isTetraquark(p) || isPentaquark(p); }

isHadron() [2/3]

template<>

bool isHadron ( const int & p )

inline

Definition at line 359 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isHadron(value_digits);}

isHadron() [3/3]

template<class T>

bool isHadron ( const T & p )

inline

Definition at line 357 of file AtlasPID.h.

{return isHadron(p->pdg_id());}

isHeavyBaryon()

template<class T>

bool isHeavyBaryon ( const T & p )

inline

Definition at line 938 of file AtlasPID.h.

{  auto lq = leadingQuark(p); return  (lq == CQUARK || lq == BQUARK || lq == TQUARK) && isBaryon(p); }

isHeavyBoson() [1/2]

template<>

bool isHeavyBoson ( const int & p )

inline

Definition at line 393 of file AtlasPID.h.

{ return p == ZPRIME || p == ZDBLPRIME || std::abs(p) == WPLUSPRIME; }

isHeavyBoson() [2/2]

template<class T>

bool isHeavyBoson ( const T & p )

inline

APID: Additional "Heavy"/"prime" versions of W and Z bosons (Used in MCTruthClassifier).

Definition at line 392 of file AtlasPID.h.

{return isHeavyBoson(p->pdg_id());}

isHeavyHadron()

template<class T>

bool isHeavyHadron ( const T & p )

inline

Definition at line 915 of file AtlasPID.h.

{  auto lq = leadingQuark(p); return  (lq == CQUARK || lq == BQUARK || lq == TQUARK ) && isHadron(p); }

isHeavyMeson()

template<class T>

bool isHeavyMeson ( const T & p )

inline

Definition at line 922 of file AtlasPID.h.

{ auto lq = leadingQuark(p); return  (lq == CQUARK || lq == BQUARK || lq == TQUARK) && isMeson(p); }

isHiddenValley() [1/3]

template<>

bool isHiddenValley ( const DecodedPID & p )

inline

Definition at line 676 of file AtlasPID.h.

                                                {
  const auto& pp = (p.ndigits() == 7) ? p.shift(2) : DecodedPID(0);
  return (p.ndigits() == 7 && p(0) == 4 && p(1) == 9 &&
          (isQuark(pp) || isLepton(pp) || isBoson(pp) || isGlueball(pp) ||
           isDiquark(pp) || isHadron(pp)));
}

isHiddenValley() [2/3]

template<>

bool isHiddenValley ( const int & p )

inline

Definition at line 682 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isHiddenValley(value_digits);}

isHiddenValley() [3/3]

template<class T>

bool 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 674 of file AtlasPID.h.

{return isHiddenValley(p->pdg_id());}

isHiggs() [1/2]

template<>

bool isHiggs ( const int & p )

inline

Definition at line 397 of file AtlasPID.h.

{ return p == HIGGSBOSON; }

isHiggs() [2/2]

template<class T>

bool isHiggs ( const T & p )

inline

APID: HIGGS boson is only one particle.

Definition at line 396 of file AtlasPID.h.

{return isHiggs(p->pdg_id());}

isKK() [1/3]

template<>

bool isKK ( const DecodedPID & p )

inline

Definition at line 642 of file AtlasPID.h.

{return (p.ndigits() == 7 && (p(0) == 5 || p(0) == 6 ) && (p(1) != 9) );}

isKK() [2/3]

template<>

bool isKK ( const int & p )

inline

Definition at line 643 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isKK(value_digits);}

isKK() [3/3]

template<class T>

bool 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 641 of file AtlasPID.h.

{return isKK(p->pdg_id());}

isLepton() [1/3]

template<>

bool isLepton ( const DecodedPID & p )

inline

Definition at line 197 of file AtlasPID.h.

{ return isLepton(p.pid()); }

isLepton() [2/3]

template<>

bool isLepton ( const int & p )

inline

Definition at line 196 of file AtlasPID.h.

{ auto sp = std::abs(p); return sp >= ELECTRON && sp <= NUPRIME; }

isLepton() [3/3]

template<class T>

bool isLepton ( const T & p )

inline

APID: the fourth generation leptons are leptons.

Definition at line 195 of file AtlasPID.h.

{return isLepton(p->pdg_id());}

isLeptoQuark() [1/2]

template<>

bool isLeptoQuark ( const int & p )

inline

Definition at line 415 of file AtlasPID.h.

{ return std::abs(p) == LEPTOQUARK; }

isLeptoQuark() [2/2]

template<class T>

bool 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 414 of file AtlasPID.h.

{return isLeptoQuark(p->pdg_id());}

isLightBaryon()

template<class T>

bool isLightBaryon ( const T & p )

inline

Definition at line 937 of file AtlasPID.h.

{ auto lq = leadingQuark(p); return  (lq == DQUARK || lq == UQUARK||lq == SQUARK) && isBaryon(p); }

isLightHadron()

template<class T>

bool isLightHadron ( const T & p )

inline

Definition at line 914 of file AtlasPID.h.

{ auto lq = leadingQuark(p); return  (lq == DQUARK || lq == UQUARK||lq == SQUARK) && isHadron(p); }

isLightMeson()

template<class T>

bool isLightMeson ( const T & p )

inline

Definition at line 921 of file AtlasPID.h.

{ auto lq = leadingQuark(p); return  (lq == DQUARK || lq == UQUARK||lq == SQUARK) && isMeson(p); }

isMeson() [1/3]

template<>

bool isMeson ( const DecodedPID & p )

inline

Definition at line 251 of file AtlasPID.h.

                                                    {
  if (p.ndigits() < 3 ) return false;
  if (p.ndigits() == 7 && (p(0) == 1 || p(0) == 2)) return false; // APID don't match SUSY particles
  if (std::abs(p.pid()) == K0S) return true;
  if (std::abs(p.pid()) == K0L) return true;
  if (std::abs(p.pid()) == K0) return true;
  if (p.last() % 2 != 1 ) return false;
  if (p.max_digit(1,3) >= QUARK_LIMIT ) return false; // Ignore pdg_ids which would describe states including fourth generation quarks
  if (p.min_digit(1,3) == 0 ) return false;
  if (*(p.second.rbegin() + 2) < *(p.second.rbegin() + 1) ) return false; // Quark ordering (nq2 >= nq3)
  if (*(p.second.rbegin() + 2) == *(p.second.rbegin() + 1) && p.pid() < 0 ) return false; // Illegal antiparticle check (nq2 == nq3)
  if (p.ndigits() == 3 ) return true;
  if (*(p.second.rbegin() + 3) != 0 ) return false; // Only two quarks! (nq1 == 0)
  if (p.ndigits() == 5 && p(0) == 1 ) return true;
  if (p.ndigits() == 5 && p(0) == 2 && p.last() > 1 ) return true;
  if (p.ndigits() == 5 && p(0) == 3 && p.last() > 1 ) return true;
  if (p.ndigits() == 6 && p.last() % 2 == 1 ) return true;
  if (p.ndigits() == 7 && p(0) == 9 && p(1) == 0 ) return true;
 
  return false;
}

isMeson() [2/3]

template<>

bool isMeson ( const int & p )

inline

Definition at line 272 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isMeson(value_digits);}

isMeson() [3/3]

template<class T>

bool 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 250 of file AtlasPID.h.

{return isMeson(p->pdg_id());}

isMonopole() [1/3]

template<>

bool isMonopole ( const DecodedPID & p )

inline

Definition at line 652 of file AtlasPID.h.

{return (p.ndigits() == 7 && p(0) == 4 && p(1) == 1  && (p(2) == 1 || p(2) == 2 ) && p(6) == 0);}

isMonopole() [2/3]

template<>

bool isMonopole ( const int & p )

inline

Definition at line 653 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isMonopole(value_digits);}

isMonopole() [3/3]

template<class T>

bool 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 651 of file AtlasPID.h.

{return isMonopole(p->pdg_id());}

isMSSMHiggs() [1/2]

template<>

bool isMSSMHiggs ( const int & p )

inline

Definition at line 401 of file AtlasPID.h.

{ return p == HIGGS2 || p == HIGGS3 || std::abs(p) == HIGGSPLUS; }

isMSSMHiggs() [2/2]

template<class T>

bool isMSSMHiggs ( const T & p )

inline

APID: Additional Higgs bosons for MSSM (Used in MCTruthClassifier).

Definition at line 400 of file AtlasPID.h.

{return isMSSMHiggs(p->pdg_id());}

isMuon() [1/2]

template<>

bool isMuon ( const int & p )

inline

Definition at line 212 of file AtlasPID.h.

{ return std::abs(p) == MUON;}

isMuon() [2/2]

template<class T>

bool isMuon ( const T & p )

inline

Definition at line 211 of file AtlasPID.h.

{return isMuon(p->pdg_id());}

isNeutral() [1/3]

template<>

bool isNeutral ( const DecodedPID & p )

inline

Definition at line 1096 of file AtlasPID.h.

{ return p.pid() != 0 && charge3(p) == 0;}

isNeutral() [2/3]

template<>

bool isNeutral ( const int & p )

inline

Definition at line 1097 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isNeutral(value_digits);}

isNeutral() [3/3]

template<class T>

bool isNeutral ( const T & p )

inline

Definition at line 1095 of file AtlasPID.h.

{ return p->pdg_id() != 0 && charge3(p) == 0;}

isNeutrino() [1/2]

template<>

bool isNeutrino ( const int & p )

inline

Definition at line 219 of file AtlasPID.h.

{ auto sp = std::abs(p); return sp == NU_E || sp == NU_MU || sp == NU_TAU || sp == NUPRIME;  }

isNeutrino() [2/2]

template<class T>

bool isNeutrino ( const T & p )

inline

APID: the fourth generation neutrinos are neutrinos.

Definition at line 218 of file AtlasPID.h.

{return isNeutrino(p->pdg_id());}

isNeutrinoRH() [1/2]

template<>

bool isNeutrinoRH ( const int & p )

inline

Definition at line 427 of file AtlasPID.h.

{ return (std::abs(p) ==  RH_NU_E || std::abs(p) ==  RH_NU_MU|| std::abs(p) ==  RH_NU_TAU);}

isNeutrinoRH() [2/2]

template<class T>

bool 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 426 of file AtlasPID.h.

{return isNeutrinoRH(p->pdg_id());}

isNucleus() [1/3]

template<>

bool isNucleus ( const DecodedPID & p )

inline

Definition at line 709 of file AtlasPID.h.

                                                      {
  if (std::abs(p.pid()) == PROTON) return true;
  if (p.ndigits() != 10) return false;
  // charge should always be less than or equal to baryon number
  // the following line is A >= Z
  const int A = p(8) + 10*p(7) + 100*p(6);
  const int Z = p(5) + 10*p(4) + 100*p(3);
  return ( A >= Z &&  p(0) == 1 &&  p(1) == 0 );
}

isNucleus() [2/3]

template<>

bool isNucleus ( const int & p )

inline

Definition at line 718 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isNucleus(value_digits);}

isNucleus() [3/3]

template<class T>

bool 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 708 of file AtlasPID.h.

{return isNucleus(p->pdg_id());}

isParton()

template<class T>

bool isParton ( const T & p )

inline

Definition at line 1113 of file AtlasPID.h.

{ return isQuark(p)||isGluon(p);}

isPentaquark() [1/3]

template<>

bool isPentaquark ( const DecodedPID & p )

inline

Definition at line 349 of file AtlasPID.h.

                                                         {
  return (p.ndigits() == 9 && p(0) == 1 &&
          p.max_digit(1,6) < QUARK_LIMIT && p.min_digit(1,6) > 0 && // ignore 4th generation (anti-)quarks
          ( p(3) >= p(4) && p(4) >= p(5) && p(5) >= p(6)) );
}

isPentaquark() [2/3]

template<>

bool isPentaquark ( const int & p )

inline

Definition at line 354 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isPentaquark(value_digits);}

isPentaquark() [3/3]

template<class T>

bool 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 348 of file AtlasPID.h.

{return isPentaquark(p->pdg_id());}

isPhoton() [1/2]

template<>

bool isPhoton ( const int & p )

inline

Definition at line 383 of file AtlasPID.h.

{ return p == PHOTON; }

isPhoton() [2/2]

template<class T>

bool isPhoton ( const T & p )

inline

Definition at line 382 of file AtlasPID.h.

{return isPhoton(p->pdg_id());}

isPythia8Specific() [1/3]

template<>

bool isPythia8Specific ( const DecodedPID & p )

inline

Definition at line 418 of file AtlasPID.h.

{ return (p.ndigits() == 7 && p(0) == 9 && p(1) == 9);}

isPythia8Specific() [2/3]

template<>

bool isPythia8Specific ( const int & p )

inline

Definition at line 419 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isPythia8Specific(value_digits);}

isPythia8Specific() [3/3]

template<class T>

bool isPythia8Specific ( const T & p )

inline

Definition at line 417 of file AtlasPID.h.

{return isPythia8Specific(p->pdg_id());}

isQuark() [1/3]

template<>

bool isQuark ( const DecodedPID & p )

inline

Definition at line 175 of file AtlasPID.h.

{ return isQuark(p.pid()); }

isQuark() [2/3]

template<>

bool isQuark ( const int & p )

inline

Definition at line 174 of file AtlasPID.h.

{ return p != 0 && (std::abs(p) <= TPRIME || std::abs(p) == MAVTOP);}

isQuark() [3/3]

template<class T>

bool 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 173 of file AtlasPID.h.

{return isQuark(p->pdg_id());}

isQuarkonium() [1/3]

template<>

bool isQuarkonium ( const DecodedPID & p )

inline

Definition at line 280 of file AtlasPID.h.

                                                          {
  if (!isMeson(p)) return false; //< all quarkonia are mesons
  return (*(p.second.rbegin() + 2) > SQUARK && p.last() > 0 && *(p.second.rbegin() + 1) == *(p.second.rbegin() + 2));
}

isQuarkonium() [2/3]

template<>

bool isQuarkonium ( const int & p )

inline

Definition at line 284 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isQuarkonium(value_digits);}

isQuarkonium() [3/3]

template<class T>

bool 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 279 of file AtlasPID.h.

{return isQuarkonium(p->pdg_id());}

isRBaryon() [1/3]

template<>

bool isRBaryon ( const DecodedPID & p )

inline

Definition at line 596 of file AtlasPID.h.

                                                       {
  if (!(p.ndigits() == 7 && (p(0) == 1 || p(0) == 2))) return false;
  auto pp = p.shift(1);
  return (
          // Handle ~gluino-quark-quark-quark states
          (pp.ndigits() == 5 && p(0) == 1 && pp(0) == COMPOSITEGLUON && pp.min_digit(1,4) > 0 && pp.max_digit(1,4) < QUARK_LIMIT && pp(2) <= pp(1) && pp(3) <= pp(2) && (pp.last() == 2 || pp.last() == 4)) ||
          // Handle squark-quark-quark states (previously called Sbaryons)
          (pp.ndigits() == 4 && pp.min_digit(1,4) > 0 && pp.max_digit(1,4) < QUARK_LIMIT && pp(1) <= pp(0) && pp(2) <= pp(1) && (pp.last() == 1 || pp.last() == 3))
          );
}

isRBaryon() [2/3]

template<>

bool isRBaryon ( const int & p )

inline

Definition at line 606 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isRBaryon(value_digits); }

isRBaryon() [3/3]

template<class T>

bool isRBaryon ( const T & p )

inline

Definition at line 595 of file AtlasPID.h.

{ return isRBaryon(p->pdg_id()); }

isResonance()

template<class T>

bool isResonance ( const T & p )

inline

Definition at line 406 of file AtlasPID.h.

{ return isZ(p) || isW(p) || isHiggs(p) || isTop(p); } // APID: not including t' (pdg_id=8), Z', Z'' and W'+ or BSM Higgs bosons

isRGlueball() [1/3]

template<>

bool isRGlueball ( const DecodedPID & p )

inline

Definition at line 569 of file AtlasPID.h.

                                                         {
  if (p.ndigits() != 7 || p(0) != 1) return false;
  auto pp = p.shift(1);
  return
    ( ( pp.ndigits() == 3 && pp(0) == COMPOSITEGLUON && pp(1) == COMPOSITEGLUON && (pp.last() == 1 || pp.last() == 3) ) ||
      ( pp.ndigits() == 4 && pp(0) == COMPOSITEGLUON && pp(1) == COMPOSITEGLUON && pp(2) == COMPOSITEGLUON && (pp.last() == 1 || pp.last() == 5) )  );
}

isRGlueball() [2/3]

template<>

bool isRGlueball ( const int & p )

inline

Definition at line 576 of file AtlasPID.h.

{  auto value_digits = DecodedPID(p);  return isRGlueball(value_digits); }

isRGlueball() [3/3]

template<class T>

bool 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 568 of file AtlasPID.h.

{ return isRGlueball(p->pdg_id()); }

isRHadron() [1/3]

template<>

bool isRHadron ( const DecodedPID & p )

inline

Definition at line 610 of file AtlasPID.h.

                                                       {
  return (isRBaryon(p) || isRMeson(p) || isRGlueball(p));
}

isRHadron() [2/3]

template<>

bool isRHadron ( const int & p )

inline

Definition at line 613 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isRHadron(value_digits); }

isRHadron() [3/3]

template<class T>

bool isRHadron ( const T & p )

inline

Definition at line 609 of file AtlasPID.h.

{ return isRHadron(p->pdg_id()); }

isRMeson() [1/3]

template<>

bool isRMeson ( const DecodedPID & p )

inline

Definition at line 581 of file AtlasPID.h.

                                                      {
  if (!(p.ndigits() == 7 && (p(0) == 1 || p(0) == 2))) return false;
  auto pp = p.shift(1);
  return (
          // Handle ~gluino-quark-antiquark states
          (pp.ndigits() == 4 && p(0) == 1 && pp(0) == COMPOSITEGLUON && pp.min_digit(1,3) > 0 && pp.max_digit(1,3) < QUARK_LIMIT && pp(2) <= pp(1) && (pp.last() == 1 || pp.last() == 3)) ||
          // Handle squark-antiquark states (previously called Smeson/mesoninos)
          (pp.ndigits() == 3 && pp.min_digit(1,3) > 0 && pp.max_digit(1,3) < QUARK_LIMIT && pp(1) <= pp(0) && pp.last() == 2)
          );
}

isRMeson() [2/3]

template<>

bool isRMeson ( const int & p )

inline

Definition at line 591 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isRMeson(value_digits); }

isRMeson() [3/3]

template<class T>

bool isRMeson ( const T & p )

inline

Definition at line 580 of file AtlasPID.h.

{ return isRMeson(p->pdg_id()); }

isSlepton() [1/3]

template<>

bool isSlepton ( const DecodedPID & p )

inline

Definition at line 489 of file AtlasPID.h.

{ auto pp = p.shift(1); return (p.ndigits() == 7 && (p(0) == 1 || p(0) == 2) && isSMLepton(pp));}

isSlepton() [2/3]

template<>

bool isSlepton ( const int & p )

inline

Definition at line 490 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isSlepton(value_digits);}

isSlepton() [3/3]

template<class T>

bool isSlepton ( const T & p )

inline

Definition at line 488 of file AtlasPID.h.

{ return isSlepton(p->pdg_id()); }

isSleptonLH() [1/3]

template<>

bool isSleptonLH ( const DecodedPID & p )

inline

Definition at line 495 of file AtlasPID.h.

                                                        {
  auto pp = p.shift(1); return (p.ndigits() == 7 && p(0) == 1 && isSMLepton(pp));
}

isSleptonLH() [2/3]

template<>

bool isSleptonLH ( const int & p )

inline

Definition at line 498 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isSleptonLH(value_digits);}

isSleptonLH() [3/3]

template<class T>

bool isSleptonLH ( const T & p )

inline

Definition at line 494 of file AtlasPID.h.

{ return isSleptonLH(p->pdg_id()); }

isSleptonRH() [1/3]

template<>

bool isSleptonRH ( const DecodedPID & p )

inline

Definition at line 503 of file AtlasPID.h.

                                                        {
  auto pp = p.shift(1); return (p.ndigits() == 7 && p(0) == 2 && isSMLepton(pp));
}

isSleptonRH() [2/3]

template<>

bool isSleptonRH ( const int & p )

inline

Definition at line 506 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isSleptonRH(value_digits);}

isSleptonRH() [3/3]

template<class T>

bool isSleptonRH ( const T & p )

inline

Definition at line 502 of file AtlasPID.h.

{ return isSleptonRH(p->pdg_id()); }

isSMLepton() [1/3]

template<>

bool isSMLepton ( const DecodedPID & p )

inline

Definition at line 202 of file AtlasPID.h.

{ return isSMLepton(p.pid()); }

isSMLepton() [2/3]

template<>

bool isSMLepton ( const int & p )

inline

Definition at line 201 of file AtlasPID.h.

{ auto sp = std::abs(p); return sp >= ELECTRON && sp <= NU_TAU; }

isSMLepton() [3/3]

template<class T>

bool isSMLepton ( const T & p )

inline

APID: the fourth generation leptons are not standard model leptons.

Definition at line 200 of file AtlasPID.h.

{return isSMLepton(p->pdg_id());}

isSMNeutrino() [1/2]

template<>

bool isSMNeutrino ( const int & p )

inline

Definition at line 222 of file AtlasPID.h.

{ auto sp = std::abs(p); return sp == NU_E || sp == NU_MU || sp == NU_TAU;  }

isSMNeutrino() [2/2]

template<class T>

bool isSMNeutrino ( const T & p )

inline

Definition at line 221 of file AtlasPID.h.

{return isSMNeutrino(p->pdg_id());}

isSMQuark() [1/3]

template<>

bool isSMQuark ( const DecodedPID & p )

inline

Definition at line 180 of file AtlasPID.h.

{ return isSMQuark(p.pid()); }

isSMQuark() [2/3]

template<>

bool isSMQuark ( const int & p )

inline

Definition at line 179 of file AtlasPID.h.

{ return p != 0 && std::abs(p) <= TQUARK;}

isSMQuark() [3/3]

template<class T>

bool isSMQuark ( const T & p )

inline

Definition at line 178 of file AtlasPID.h.

{return isSMQuark(p->pdg_id());}

isSquark() [1/3]

template<>

bool isSquark ( const DecodedPID & p )

inline

Definition at line 465 of file AtlasPID.h.

                                                     {
  auto pp = p.shift(1); return (p.ndigits() == 7 && (p(0) == 1 || p(0) == 2) && isSMQuark(pp));
}

isSquark() [2/3]

template<>

bool isSquark ( const int & p )

inline

Definition at line 468 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isSquark(value_digits);}

isSquark() [3/3]

template<class T>

bool 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 464 of file AtlasPID.h.

{ return isSquark(p->pdg_id()); }

isSquarkLH() [1/3]

template<>

bool isSquarkLH ( const DecodedPID & p )

inline

Definition at line 473 of file AtlasPID.h.

                                                       {
  auto pp = p.shift(1); return (p.ndigits() == 7 && p(0) == 1 && isSMQuark(pp));
}

isSquarkLH() [2/3]

template<>

bool isSquarkLH ( const int & p )

inline

Definition at line 476 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isSquarkLH(value_digits);}

isSquarkLH() [3/3]

template<class T>

bool isSquarkLH ( const T & p )

inline

Definition at line 472 of file AtlasPID.h.

{ return isSquarkLH(p->pdg_id()); }

isSquarkRH() [1/3]

template<>

bool isSquarkRH ( const DecodedPID & p )

inline

Definition at line 481 of file AtlasPID.h.

                                                       {
  auto pp = p.shift(1); return (p.ndigits() == 7 && p(0) == 2 && isSMQuark(pp));
}

isSquarkRH() [2/3]

template<>

bool isSquarkRH ( const int & p )

inline

Definition at line 484 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isSquarkRH(value_digits);}

isSquarkRH() [3/3]

template<class T>

bool isSquarkRH ( const T & p )

inline

Definition at line 480 of file AtlasPID.h.

{ return isSquarkRH(p->pdg_id()); }

isStrange() [1/2]

template<>

bool isStrange ( const int & p )

inline

Definition at line 183 of file AtlasPID.h.

{ return std::abs(p) == SQUARK;}

isStrange() [2/2]

template<class T>

bool isStrange ( const T & p )

inline

Definition at line 182 of file AtlasPID.h.

{return isStrange(p->pdg_id());}

isStrangeBaryon()

template<class T>

bool isStrangeBaryon ( const T & p )

inline

Definition at line 939 of file AtlasPID.h.

{ return  leadingQuark(p) == SQUARK && isBaryon(p); }

isStrangeHadron()

template<class T>

bool isStrangeHadron ( const T & p )

inline

Definition at line 916 of file AtlasPID.h.

{ return  leadingQuark(p) == SQUARK && isHadron(p); }

isStrangeMeson()

template<class T>

bool isStrangeMeson ( const T & p )

inline

Definition at line 923 of file AtlasPID.h.

{ return  leadingQuark(p) == SQUARK && isMeson(p); }

isStrongInteracting() [1/2]

template<>

bool isStrongInteracting ( const int & p )

inline

Definition at line 1189 of file AtlasPID.h.

{ return (isGluon(p) || isQuark(p) || isDiquark(p) || isGlueball(p) || isLeptoQuark(p) || isHadron(p) || isRHadron(p));} // APID: Glueballs and R-Hadrons are also strong-interacting

isStrongInteracting() [2/2]

template<class T>

bool isStrongInteracting ( const T & p )

inline

Definition at line 1188 of file AtlasPID.h.

{return isStrongInteracting(p->pdg_id());}

isSuperpartner() [1/3]

template<>

bool isSuperpartner ( const DecodedPID & p )

inline

Definition at line 519 of file AtlasPID.h.

                                                           {
  return isSlepton(p) || isSquark(p) || isGaugino(p);
}

isSuperpartner() [2/3]

template<>

bool isSuperpartner ( const int & p )

inline

Definition at line 522 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isSuperpartner(value_digits);}

isSuperpartner() [3/3]

template<class T>

bool isSuperpartner ( const T & p )

inline

Definition at line 518 of file AtlasPID.h.

{ return isSuperpartner(p->pdg_id()); }

isSUSY() [1/3]

template<>

bool isSUSY ( const DecodedPID & p )

inline

Definition at line 630 of file AtlasPID.h.

{return (isSuperpartner(p) || isRHadron(p));}

isSUSY() [2/3]

template<>

bool isSUSY ( const int & p )

inline

Definition at line 631 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isSUSY(value_digits);}

isSUSY() [3/3]

template<class T>

bool isSUSY ( const T & p )

inline

Definition at line 629 of file AtlasPID.h.

{return isSUSY(p->pdg_id());}

isTau() [1/2]

template<>

bool isTau ( const int & p )

inline

Definition at line 215 of file AtlasPID.h.

{ return std::abs(p) == TAU;}

isTau() [2/2]

template<class T>

bool isTau ( const T & p )

inline

Definition at line 214 of file AtlasPID.h.

{return isTau(p->pdg_id());}

isTechnicolor() [1/3]

template<>

bool isTechnicolor ( const DecodedPID & p )

inline

Definition at line 532 of file AtlasPID.h.

                                               {
  const auto& pp = (p.ndigits() == 7) ? p.shift(2) : DecodedPID(0);
  return (p.ndigits() == 7 && p(0) == 3 && (p(1) == 0 || p(1) == 1) &&
          (isQuark(pp) || isLepton(pp) || isBoson(pp) || isGlueball(pp) ||
           isDiquark(pp) || isHadron(pp)));
}

isTechnicolor() [2/3]

template<>

bool isTechnicolor ( const int & p )

inline

Definition at line 538 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isTechnicolor(value_digits);}

isTechnicolor() [3/3]

template<class T>

bool 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 530 of file AtlasPID.h.

{return isTechnicolor(p->pdg_id());}

isTetraquark() [1/3]

template<>

bool isTetraquark ( const DecodedPID & p )

inline

Definition at line 332 of file AtlasPID.h.

                                                         {
  return (p.ndigits() == 9 && p(0) == 1 && p(5) == 0 &&
          p.max_digit(1,3) < QUARK_LIMIT && p.min_digit(1,3) > 0 && // ignore 4th generation quarks for nq3 and nq4
          p.max_digit(4,6) < QUARK_LIMIT && p.min_digit(4,6) > 0 && // ignore 4th generation quarks for nq1 and nq2
          ( p(3) >= p(4) && p(6) >= p(7) ) && ( ( p(3) > p(6) ) || ( p(3) == p(6) && (p(4) >= p(7))))
          );
}

isTetraquark() [2/3]

template<>

bool isTetraquark ( const int & p )

inline

Definition at line 339 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isTetraquark(value_digits);}

isTetraquark() [3/3]

template<class T>

bool 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 331 of file AtlasPID.h.

{return isTetraquark(p->pdg_id());}

isTop() [1/2]

template<>

bool isTop ( const int & p )

inline

Definition at line 192 of file AtlasPID.h.

{ return std::abs(p) == TQUARK;}

isTop() [2/2]

template<class T>

bool isTop ( const T & p )

inline

Definition at line 191 of file AtlasPID.h.

{return isTop(p->pdg_id());}

isTopBaryon()

template<class T>

bool isTopBaryon ( const T & p )

inline

Definition at line 942 of file AtlasPID.h.

{ return  leadingQuark(p) == TQUARK && isBaryon(p); }

isTopHadron()

template<class T>

bool isTopHadron ( const T & p )

inline

Definition at line 919 of file AtlasPID.h.

{ return  leadingQuark(p) == TQUARK && isHadron(p); }

isTopMeson()

template<class T>

bool isTopMeson ( const T & p )

inline

Definition at line 926 of file AtlasPID.h.

{ return  leadingQuark(p) == TQUARK && isMeson(p); }

isTrajectory() [1/2]

template<>

bool isTrajectory ( const int & p )

inline

Definition at line 366 of file AtlasPID.h.

{ return std::abs(p) == POMERON || std::abs(p) == ODDERON || std::abs(p) == REGGEON; }

isTrajectory() [2/2]

template<class T>

bool 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 365 of file AtlasPID.h.

{return isTrajectory(p->pdg_id());}

isTransportable() [1/3]

template<>

bool isTransportable ( const DecodedPID & p )

inline

Definition at line 880 of file AtlasPID.h.

{ return isPhoton(p.pid()) || isGeantino(p.pid()) || isHadron(p) || isLepton(p.pid()) || p.pid() == DARKPHOTON;}

isTransportable() [2/3]

template<>

bool isTransportable ( const int & p )

inline

Definition at line 881 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return isTransportable(value_digits);}

isTransportable() [3/3]

template<class T>

bool isTransportable ( const T & p )

inline

Definition at line 879 of file AtlasPID.h.

{return isTransportable(p->pdg_id());}

isValid() [1/3]

template<>

bool isValid ( const DecodedPID & p )

inline

Definition at line 885 of file AtlasPID.h.

                                                    {
  return p.pid() !=0 && ( isQuark(p) || isLepton(p) || isBoson(p) || isGlueball(p) ||
                         isTrajectory(p.pid()) || isGenSpecific(p.pid()) || isDiquark(p) ||
                         isBSM(p) || isHadron(p) || isNucleus(p) || isGeantino(p.pid()) ||
                         isPythia8Specific(p) ); }

isValid() [2/3]

template<>

bool isValid ( const int & p )

inline

Definition at line 890 of file AtlasPID.h.

                                             { if (!p) return false; if (std::abs(p) < 42) return true;
  if (isGenSpecific(p)) return true;
  auto value_digits = DecodedPID(p); return isValid(value_digits);
}

isValid() [3/3]

template<class T>

bool isValid ( const T & p )

inline

Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.

Definition at line 884 of file AtlasPID.h.

{return isValid(p->pdg_id());}

isW() [1/2]

template<>

bool isW ( const int & p )

inline

Definition at line 389 of file AtlasPID.h.

{ return std::abs(p) == WPLUSBOSON; }

isW() [2/2]

template<class T>

bool isW ( const T & p )

inline

Definition at line 388 of file AtlasPID.h.

{return isW(p->pdg_id());}

isWeaklyDecayingBHadron() [1/3]

template<>

bool isWeaklyDecayingBHadron ( const DecodedPID & p )

inline

Definition at line 974 of file AtlasPID.h.

{ return isWeaklyDecayingBHadron(p.pid()); }

isWeaklyDecayingBHadron() [2/3]

template<>

bool isWeaklyDecayingBHadron ( const int & p )

inline

Definition at line 949 of file AtlasPID.h.

                                                              {
  const int pid = std::abs(p);
  return ( pid == 511   || // B0
           pid == 521   || // B+
           pid == 531   || // B_s0
           pid == 541   || // B_c+
           pid == 5122  || // Lambda_b0
           pid == 5132  || // Xi_b-
           pid == 5232  || // Xi_b0
           pid == 5112  || // Sigma_b-
           pid == 5212  || // Sigma_b0
           pid == 5222  || // Sigma_b+
           pid == 5332  || // Omega_b-
           pid == 5142  || // Xi_bc0
           pid == 5242  || // Xi_bc+
           pid == 5412  || // Xi'_bc0
           pid == 5422  || // Xi'_bc+
           pid == 5342  || // Omega_bc0
           pid == 5432  || // Omega'_bc0
           pid == 5442  || // Omega_bcc+
           pid == 5512  || // Xi_bb-
           pid == 5522  || // Xi_bb0
           pid == 5532  || // Omega_bb-
           pid == 5542  ); // Omega_bbc0
}

isWeaklyDecayingBHadron() [3/3]

template<class T>

bool isWeaklyDecayingBHadron ( const T & p )

inline

Definition at line 948 of file AtlasPID.h.

{return isWeaklyDecayingBHadron(p->pdg_id());}

isWeaklyDecayingCHadron() [1/3]

template<>

bool isWeaklyDecayingCHadron ( const DecodedPID & p )

inline

Definition at line 998 of file AtlasPID.h.

{ return isWeaklyDecayingCHadron(p.pid()); }

isWeaklyDecayingCHadron() [2/3]

template<>

bool isWeaklyDecayingCHadron ( const int & p )

inline

Definition at line 984 of file AtlasPID.h.

                                                              {
  const int pid = std::abs(p);
  return ( pid == 411   || // D+
           pid == 421   || // D0
           pid == 431   || // Ds+
           pid == 4122  || // Lambda_c+
           pid == 4132  || // Xi_c0
           pid == 4232  || // Xi_c+
           pid == 4212  || // Xi_c0
           pid == 4332  || // Omega_c0
           pid == 4412  || // Xi_cc+
           pid == 4422  || // Xi_cc++
           pid == 4432  ); // Omega_cc+
}

isWeaklyDecayingCHadron() [3/3]

template<class T>

bool isWeaklyDecayingCHadron ( const T & p )

inline

Definition at line 983 of file AtlasPID.h.

{return isWeaklyDecayingCHadron(p->pdg_id());}

isZ() [1/2]

template<>

bool isZ ( const int & p )

inline

Definition at line 386 of file AtlasPID.h.

{ return p == Z0BOSON; }

isZ() [2/2]

template<class T>

bool isZ ( const T & p )

inline

Definition at line 385 of file AtlasPID.h.

{return isZ(p->pdg_id());}

leadingQuark() [1/3]

template<>

int leadingQuark ( const DecodedPID & p )

inline

Definition at line 896 of file AtlasPID.h.

                                                        {
  if (isQuark(p.pid())) { return std::abs(p.pid());}
  if (isMeson(p)) { return p.max_digit(1,3);}
  if (isDiquark(p)) { return p.max_digit(2,4);}
  if (isBaryon(p)) { return p.max_digit(1,4);}
  if (isTetraquark(p)) { return p.max_digit(1,5);}
  if (isPentaquark(p)) { return p.max_digit(1,6);}
  if (isSUSY(p)) { // APID SUSY case
    auto pp = p.shift(1);
    if ( pp.ndigits() == 1 ) { return 0; } // Handle squarks
    if ( pp.ndigits() == 3 ) { pp = DecodedPID(pp(1)); } // Handle ~q qbar pairs
    if ( pp.ndigits()  > 3 ) { pp = pp.shift(1); } // Drop gluinos and squarks
    return leadingQuark(pp); }
  return 0;
}

leadingQuark() [2/3]

template<>

int leadingQuark ( const int & p )

inline

Definition at line 912 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return leadingQuark(value_digits);}

leadingQuark() [3/3]

template<class T>

int leadingQuark ( const T & p )

inline

Definition at line 895 of file AtlasPID.h.

{return leadingQuark(p->pdg_id());}

numberOfLambdas() [1/3]

template<>

int numberOfLambdas ( const DecodedPID & p )

inline

Definition at line 831 of file AtlasPID.h.

                                                           {
  if (std::abs(p.pid()) == LAMBDA0) { return  (p.pid() > 0) ? 1 : -1; }
  if (isNucleus(p) && p.ndigits() == 10) { return (p.pid() > 0) ? p(2) : -p(2); }
  return 0;
}

numberOfLambdas() [2/3]

template<>

int numberOfLambdas ( const int & p )

inline

Definition at line 836 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return numberOfLambdas(value_digits);}

numberOfLambdas() [3/3]

template<class T>

int numberOfLambdas ( const T & p )

inline

Definition at line 830 of file AtlasPID.h.

{return numberOfLambdas(p->pdg_id());}

numberOfProtons() [1/3]

template<>

int numberOfProtons ( const DecodedPID & p )

inline

Definition at line 840 of file AtlasPID.h.

                                                           {
  if (std::abs(p.pid()) == PROTON) { return  (p.pid() > 0) ? 1 : -1; }
  if (isNucleus(p)) {
    const int result = p(5) + 10*p(4) + 100*p(3);
    return (p.pid() > 0) ? result : -result;
  }
  return 0;
}

numberOfProtons() [2/3]

template<>

int numberOfProtons ( const int & p )

inline

Definition at line 848 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return numberOfProtons(value_digits);}

numberOfProtons() [3/3]

template<class T>

int numberOfProtons ( const T & p )

inline

Definition at line 839 of file AtlasPID.h.

{return numberOfProtons(p->pdg_id());}

spin() [1/3]

template<>

double spin ( const DecodedPID & p )

inline

Definition at line 1158 of file AtlasPID.h.

{ return 1.0*spin2(p)/2.0; }

spin() [2/3]

template<>

double spin ( const int & p )

inline

Definition at line 1159 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return spin(value_digits);}

spin() [3/3]

template<class T>

double spin ( const T & p )

inline

Definition at line 1157 of file AtlasPID.h.

{ return spin(p->pdg_id()); }

spin2() [1/3]

template<>

int spin2 ( const DecodedPID & p )

inline

Definition at line 1118 of file AtlasPID.h.

                                                  {
  if (isSUSY(p)) {
    auto pp = p.shift(1);
    auto ap = std::abs(pp.pid());
    if (ap < TABLESIZE ) { return std::abs(double_spin.at(ap)-1); } // sparticles (0->1, 1 -> 0,  2->1,  4->3)
    return p.last()-1; // R-Hadrons (p.last() == 2J +1)
  }
  if (isHiddenValley(p)) { //Hidden Valley spins
    auto pp = p.shift(2);
    if (isHadron(pp)) { return pp.last()-1; } // Hadrons (p.last == 2J+1 - special cases handled above)
  }
  if (isKK(p)) { // Kaluza-Klein spins
    auto pp = p.shift(2);
    auto ap = std::abs(pp.pid());
    if (ap < TABLESIZE ) { return double_spin.at(ap); } // fundamental particles
  }
  if (isDM(std::abs(p.pid()))) { //DM spins
    if (p.ndigits() == 7) { // Determining the spins for the more elaborate, 7-digit DM codes
      auto pp = p.shift(3); // The first two digits indicate the particle is DM, the third indicates left/right-handedness (see 11(j))
      auto ap = std::abs(pp.pid());
      if (ap < TABLESIZE) { return double_spin.at(ap); } // fundamental particles
    }else if (std::abs(p.pid()) < TABLESIZE) { // Just to make sure the correct spin is returned for DM 51-60
      return std::abs(double_spin.at(std::abs(p.pid())));
    }
  }
  auto ap = std::abs(p.pid());
  if (ap == K0S) { return 0; }
  if (ap == K0L) { return 0; }
  if (ap == MAVTOP) { return 1; } // TODO check this
  if (ap == DARKPHOTON) { return 2; } // TODO check this
  if (ap < TABLESIZE ) { return double_spin.at(ap); } // fundamental particles
  if (isHadron(p)) { return p.last()-1; } // Hadrons (p.last == 2J+1 - special cases handled above)
  if (isMonopole(p)) { return 0; } // PDG 11i - For now no spin information is provided. Also matches the definition in the G4Extensions/Monopole package.
  if (isGenericMultichargedParticle(p)) { return 0; } // APID Matches the definition in the G4Extensions/Monopole package.
  if (isNucleus(p)) { return 1; }  // TODO need to explicitly deal with nuclei
  return p.last() > 0 ? 1 : 0; //  Anything else - best guess
}

spin2() [2/3]

template<>

int spin2 ( const int & p )

inline

Definition at line 1155 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return spin2(value_digits);}

spin2() [3/3]

template<class T>

int spin2 ( const T & p )

inline

Definition at line 1117 of file AtlasPID.h.

{ return spin2(p->pdg_id()); }

strangeness() [1/3]

template<>

int strangeness ( const DecodedPID & p )

inline

Definition at line 793 of file AtlasPID.h.

                                                       {
  if (isNucleus(p) && p.ndigits() == 10) { return (p.pid() > 0) ? -p(2) : p(2); }
  if (isStrange(p.pid())) { return (p.pid() > 0) ? -1 : 1; }
  if (!hasStrange(p) && !hasSquark(p,SQUARK)) { return 0; }
  if (std::abs(p.pid()) == K0) { return (p.pid() > 0) ? 1 : -1; }
  size_t nq = 0;
  int sign = 1;
  int signmult = 1;
  int result=0;
  bool classified = false;
  if (!classified && isMeson(p)) { classified = true; nq = 2; if ((*(p.second.rbegin()+2)) == 2||(*(p.second.rbegin()+2)) == 4 ) { sign=-1;} signmult =-1; }
  if (!classified && isDiquark(p)) {return is_strange.at(p(0))+is_strange.at(p(1)); }
  if (!classified && isBaryon(p)) { classified = true; nq = 3; }
  if (!classified && isTetraquark(p)){ return is_strange.at(p(3)) + is_strange.at(p(4)) - is_strange.at(p(6)) - is_strange.at(p(7)); }
  if (!classified && isPentaquark(p)){ return is_strange.at(p(3)) + is_strange.at(p(4)) + is_strange.at(p(5)) + is_strange.at(p(6)) - is_strange.at(p(7)); }
  if (!classified && isSUSY(p)) {
    nq = 0;
    auto pp = p.shift(1);
    if (pp.ndigits() < 3 ) { return strangeness(pp); } // super-partners of fundamental particles
    if (pp(0) == COMPOSITEGLUON) {
      if (pp(1) == COMPOSITEGLUON) { return 0; } // R-Glueballs
      if ( pp.ndigits() == 4 || pp.ndigits() == 5) {
        pp = pp.shift(1); // Remove gluino
      }
    }
    if (pp.ndigits() == 3) { classified = true; nq = 2; if (p.last()%2==0) {sign = -1;} signmult = -1; } // states with quark-antiquark or squark-antiquark
    if (pp.ndigits() == 4) { classified = true; nq = 3; } // states with quark-quark-quark or squark-quark-quark
  }
  for (auto r = p.second.rbegin() + 1; r != p.second.rbegin() + 1 + nq; ++r) {
    result += is_strange.at(*r)*sign;
    sign*=signmult;
  }
  return p.pid() > 0 ? result : -result;
}

strangeness() [2/3]

template<>

int strangeness ( const int & p )

inline

Definition at line 827 of file AtlasPID.h.

{ auto value_digits = DecodedPID(p); return strangeness(value_digits);}

strangeness() [3/3]

template<class T>

int strangeness ( const T & p )

inline

Definition at line 792 of file AtlasPID.h.

{return strangeness(p->pdg_id());}

threeCharge()

template<class T>

double threeCharge ( const T & p )

inline

Definition at line 1009 of file AtlasPID.h.

{ return charge3(p);}

Variable Documentation

ARGON

const int ARGON = 1000180400

static

Definition at line 145 of file AtlasPID.h.

B0

const int B0 = 511

static

Definition at line 122 of file AtlasPID.h.

BCPLUS

const int BCPLUS = 541

static

Definition at line 123 of file AtlasPID.h.

BORON

const int BORON = 1000050110

static

Definition at line 149 of file AtlasPID.h.

BPRIME

const int BPRIME = 7

static

Definition at line 70 of file AtlasPID.h.

BQUARK

const int BQUARK = 5

static

Definition at line 68 of file AtlasPID.h.

CALCIUM

const int CALCIUM = 1000200400

static

Definition at line 144 of file AtlasPID.h.

COMPOSITEGLUON

const int COMPOSITEGLUON = 9

static

Definition at line 86 of file AtlasPID.h.

CQUARK

const int CQUARK = 4

static

Definition at line 67 of file AtlasPID.h.

D0

const int D0 = 421

static

Definition at line 119 of file AtlasPID.h.

DARKPHOTON

const int 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 106 of file AtlasPID.h.

double_spin

const std::array<int,TABLESIZE> 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 50 of file AtlasPID.h.

                                                 {
  +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
};

DPLUS

const int DPLUS = 411

static

Definition at line 117 of file AtlasPID.h.

DQUARK

const int DQUARK = 1

static

Definition at line 64 of file AtlasPID.h.

DSPLUS

const int DSPLUS = 431

static

Definition at line 120 of file AtlasPID.h.

DSTAR

const int DSTAR = 413

static

Definition at line 118 of file AtlasPID.h.

ELECTRON

const int ELECTRON = 11

static

Definition at line 74 of file AtlasPID.h.

GEANTINO0

const int GEANTINO0 = 999

static

Definition at line 165 of file AtlasPID.h.

GEANTINOPLUS

const int 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 164 of file AtlasPID.h.

GLUON

const int GLUON = 21

static

Definition at line 84 of file AtlasPID.h.

GRAVITON

const int GRAVITON = 39

static

Definition at line 98 of file AtlasPID.h.

HELIUM

const int HELIUM = 1000020040

static

Definition at line 150 of file AtlasPID.h.

HIGGS2

const int HIGGS2 = 35

static

Definition at line 94 of file AtlasPID.h.

HIGGS3

const int HIGGS3 = 36

static

Definition at line 95 of file AtlasPID.h.

HIGGS4

const int HIGGS4 = 40

static

Definition at line 99 of file AtlasPID.h.

HIGGSBOSON

const int HIGGSBOSON = 25

static

Definition at line 90 of file AtlasPID.h.

HIGGSPLUS

const int HIGGSPLUS = 37

static

Definition at line 96 of file AtlasPID.h.

HIGGSPLUSPLUS

const int HIGGSPLUSPLUS = 38

static

Definition at line 97 of file AtlasPID.h.

INDIUM

const int INDIUM = 1000491150

static

Definition at line 142 of file AtlasPID.h.

is_strange

const std::array<int,10> is_strange

static

Initial value:

                                 = {
+0, +0, +0, -1, +0, +0, +0, +0, +0, +0 }

Definition at line 790 of file AtlasPID.h.

                                         {
  +0, +0, +0, -1, +0, +0, +0, +0, +0, +0 };

JPSI

const int JPSI = 443

static

Definition at line 121 of file AtlasPID.h.

K0

const int K0 = 311

static

Definition at line 115 of file AtlasPID.h.

K0L

const int K0L = 130

static

Definition at line 112 of file AtlasPID.h.

K0S

const int K0S = 310

static

Definition at line 114 of file AtlasPID.h.

KPLUS

const int KPLUS = 321

static

Definition at line 116 of file AtlasPID.h.

KRYPTON

const int KRYPTON = 1000360840

static

Definition at line 143 of file AtlasPID.h.

LAMBDA0

const int LAMBDA0 = 3122

static

Definition at line 126 of file AtlasPID.h.

LAMBDAB0

const int LAMBDAB0 = 5122

static

Definition at line 128 of file AtlasPID.h.

LAMBDACPLUS

const int LAMBDACPLUS = 4122

static

Definition at line 127 of file AtlasPID.h.

LEAD

const int LEAD = 1000822080

static

Definition at line 141 of file AtlasPID.h.

LEPTOQUARK

const int LEPTOQUARK = 42

static

Definition at line 100 of file AtlasPID.h.

LPRIME

const int LPRIME = 17

static

Definition at line 81 of file AtlasPID.h.

MAGNESIUM

const int MAGNESIUM = 1000120240

static

Definition at line 146 of file AtlasPID.h.

MAVTOP

const int MAVTOP = 60001

static

Definition at line 107 of file AtlasPID.h.

MUON

const int MUON = 13

static

Definition at line 77 of file AtlasPID.h.

NEON

const int NEON = 1000100200

static

Definition at line 147 of file AtlasPID.h.

NEUTRON

const int NEUTRON = 2112

static

Definition at line 125 of file AtlasPID.h.

NU_E

const int NU_E = 12

static

Definition at line 76 of file AtlasPID.h.

NU_MU

const int NU_MU = 14

static

Definition at line 78 of file AtlasPID.h.

NU_TAU

const int NU_TAU = 16

static

Definition at line 80 of file AtlasPID.h.

NUPRIME

const int NUPRIME = 18

static

Definition at line 82 of file AtlasPID.h.

ODDERON

const int ODDERON = 9990

static

Definition at line 156 of file AtlasPID.h.

OXYGEN

const int OXYGEN = 1000080160

static

Definition at line 148 of file AtlasPID.h.

PHOTON

const int PHOTON = 22

static

Definition at line 87 of file AtlasPID.h.

PI0

const int PI0 = 111

static

Definition at line 111 of file AtlasPID.h.

PIMINUS

const int PIMINUS = -PIPLUS

static

Definition at line 110 of file AtlasPID.h.

PIPLUS

const int PIPLUS = 211

static

Definition at line 109 of file AtlasPID.h.

POMERON

const int 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 155 of file AtlasPID.h.

POSITRON

const int POSITRON = -ELECTRON

static

Definition at line 75 of file AtlasPID.h.

PROTON

const int PROTON = 2212

static

Definition at line 124 of file AtlasPID.h.

PSI2S

const int PSI2S = 20443

static

Definition at line 129 of file AtlasPID.h.

QUARK_LIMIT

const int QUARK_LIMIT = BPRIME

static

Definition at line 72 of file AtlasPID.h.

REGGEON

const int REGGEON = 110

static

Definition at line 157 of file AtlasPID.h.

RH_NU_E

const int 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 136 of file AtlasPID.h.

RH_NU_MU

const int RH_NU_MU = 9900014

static

Definition at line 137 of file AtlasPID.h.

RH_NU_TAU

const int RH_NU_TAU = 9900016

static

Definition at line 138 of file AtlasPID.h.

SQUARK

const int SQUARK = 3

static

Definition at line 66 of file AtlasPID.h.

TABLESIZE

const int TABLESIZE = 100

static

Definition at line 34 of file AtlasPID.h.

TAU

const int TAU = 15

static

Definition at line 79 of file AtlasPID.h.

TPRIME

const int TPRIME = 8

static

Definition at line 71 of file AtlasPID.h.

TQUARK

const int TQUARK = 6

static

Definition at line 69 of file AtlasPID.h.

triple_charge

const std::array<int,TABLESIZE> 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 35 of file AtlasPID.h.

                                                   {
  +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
};

UQUARK

const int UQUARK = 2

static

Definition at line 65 of file AtlasPID.h.

WBOSON_LRSM

const int WBOSON_LRSM = 9900024

static

Definition at line 139 of file AtlasPID.h.

WPLUSBOSON

const int WPLUSBOSON = 24

static

Definition at line 89 of file AtlasPID.h.

WPLUSPRIME

const int WPLUSPRIME = 34

static

Definition at line 93 of file AtlasPID.h.

Z0BOSON

const int Z0BOSON = 23

static

Definition at line 88 of file AtlasPID.h.

ZDBLPRIME

const int ZDBLPRIME = 33

static

Definition at line 92 of file AtlasPID.h.

ZPRIME

const int ZPRIME = 32

static

Definition at line 91 of file AtlasPID.h.