Classes
class	ParticleNames
Functions
const std::string &	toParticleName (PdgId p)
	Print a PdgId as a named string.
PdgId	toParticleId (const std::string &pname)
	Print a PdgId as a named string.
std::pair< PdgId, PdgId >	make_pdgid_pair (PdgId a, PdgId b)
	Convenience maker of particle ID pairs from PdgIds.
std::pair< PdgId, PdgId >	make_pdgid_pair (const std::string &a, const std::string &b)
	Convenience maker of particle ID pairs from particle names.
std::string	toBeamsString (const PdgIdPair &pair)
	Print a PdgIdPair as a string.
Nucleus/ion functions
bool	isNucleus (int pid)
	Is this a nucleus PID?
int	Z (int pid)
int	A (int pid)
int	lambda (int pid)
Quark composite functions
bool	isMeson (int pid)
	Check to see if this is a valid meson.
bool	isBaryon (int pid)
	Check to see if this is a valid baryon.
bool	isDiquark (int pid)
bool	isDiQuark (int pid)
bool	isPentaquark (int pid)
	Check to see if this is a valid pentaquark.
bool	isHadron (int pid)
	Is this a valid hadron ID?
More general particle class identification functions
bool	isLepton (int pid)
	Is this a valid lepton ID?
bool	isSUSY (int pid)
	Is this a fundamental SUSY particle?
bool	isRhadron (int pid)
	Is this an R-hadron?
bool	isRHadron (int pid)
bool	isTechnicolor (int pid)
	Is this a technicolor particle?
bool	isExcited (int pid)
	Is this an excited (composite) quark or lepton?
bool	isKK (int pid)
	Is this a Kaluza-Klein excitation?
bool	isGraviton (int pid)
	Is this a graviton?
bool	isBSM (int pid)
	Is this a BSM particle (including graviton)?
bool	isReggeon (int pid)
	Is this a pomeron, odderon, or generic reggeon?
bool	isValid (int pid)
	Check to see if this is a valid PID (i.e. matches any known scheme)
Parton content functions
bool	hasUp (const int &pid)
	Does this particle contain an up quark?
bool	hasDown (const int &pid)
	Does this particle contain a down quark?
bool	hasStrange (int pid)
	Does this particle contain a strange quark?
bool	hasCharm (int pid)
	Does this particle contain a charm quark?
bool	hasBottom (int pid)
	Does this particle contain a bottom quark?
bool	hasTop (int pid)
	Does this particle contain a top quark?
Angular momentum functions
int	jSpin (int pid)
	jSpin returns 2J+1, where J is the total spin
int	sSpin (int pid)
	sSpin returns 2S+1, where S is the spin
int	lSpin (int pid)
	lSpin returns 2L+1, where L is the orbital angular momentum
Charge functions
int	threeCharge (int pid)
	Three times the charge (as integer)
double	charge (int pid)
	Return the charge (as floating point)
General PID-based classifier functions
bool	isCharged (int pid)
	Determine if the particle is electrically charged.
bool	isNeutral (int pid)
	Determine if the particle is electrically neutral.
Fundamental particles
bool	isQuark (int pid)
	Determine if the PID is that of a quark.
bool	isParton (int pid)
	Determine if the PID is that of a parton (quark or gluon)
bool	isPhoton (int pid)
	Determine if the PID is that of a photon.
bool	isElectron (int pid)
	Determine if the PID is that of an electron or positron.
bool	isMuon (int pid)
	Determine if the PID is that of an muon or antimuon.
bool	isTau (int pid)
	Determine if the PID is that of an tau or antitau.
bool	isChLepton (int pid)
	Determine if the PID is that of a charged lepton.
bool	isNeutrino (int pid)
	Determine if the PID is that of a neutrino.
bool	isWplus (int pid)
	Determine if the PID is that of a W+.
bool	isWminus (int pid)
	Determine if the PID is that of a W-.
bool	isW (int pid)
	Determine if the PID is that of a W+-.
bool	isZ (int pid)
	Determine if the PID is that of a Z0.
bool	isHiggs (int pid)
	Determine if the PID is that of an SM/lightest SUSY Higgs.
bool	isTop (int pid)
	Determine if the PID is that of a t/tbar.
Hadron and parton flavour classification
bool	isHeavyFlavour (int pid)
	Determine if the particle is a heavy flavour hadron or parton.
bool	isHeavyParton (int pid)
	Determine if the PID is that of a heavy parton (c,b,t)
bool	isLightParton (int pid)
	Determine if the PID is that of a light parton (u,d,s)
bool	isHeavyMeson (int pid)
	Determine if the PID is that of a heavy flavour (b or c) meson.
bool	isHeavyBaryon (int pid)
	Determine if the PID is that of a heavy flavour (b or c) baryon.
bool	isHeavyHadron (int pid)
	Determine if the PID is that of a heavy flavour (b or c) hadron.
bool	isLightMeson (int pid)
	Determine if the PID is that of a light flavour (not b or c) meson.
bool	isLightBaryon (int pid)
	Determine if the PID is that of a light flavour (not b or c) baryon.
bool	isLightHadron (int pid)
	Determine if the PID is that of a light flavour (not b or c) hadron.
bool	isBottomMeson (int pid)
	Determine if the PID is that of a b-meson.
bool	isBottomBaryon (int pid)
	Determine if the PID is that of a b-baryon.
bool	isBottomHadron (int pid)
	Determine if the PID is that of a b-hadron.
bool	isCharmMeson (int pid)
	Determine if the PID is that of a c-meson.
bool	isCharmBaryon (int pid)
	Determine if the PID is that of a c-baryon.
bool	isCharmHadron (int pid)
Other classifiers
bool	isGenSpecific (int pid)
	Determine if the PID is in the generator-specific range.
bool	isResonance (int pid)
bool	isTransportable (int pid)
Variables
static const PdgId	ANY = 10000
	Static const convenience particle ID names.
Charged leptons
static const PdgId	ELECTRON = 11
static const PdgId	POSITRON = -ELECTRON
static const PdgId	EMINUS = ELECTRON
static const PdgId	EPLUS = POSITRON
static const PdgId	MUON = 13
static const PdgId	ANTIMUON = -MUON
static const PdgId	TAU = 15
static const PdgId	ANTITAU = -TAU
Neutrinos
static const PdgId	NU_E = 12
static const PdgId	NU_EBAR = -NU_E
static const PdgId	NU_MU = 14
static const PdgId	NU_MUBAR = -NU_MU
static const PdgId	NU_TAU = 16
static const PdgId	NU_TAUBAR = -NU_TAU
Bosons
static const PdgId	PHOTON = 22
static const PdgId	GAMMA = PHOTON
static const PdgId	GLUON = 21
static const PdgId	WPLUSBOSON = 24
static const PdgId	WMINUSBOSON = -WPLUSBOSON
static const PdgId	WPLUS = WPLUSBOSON
static const PdgId	WMINUS = WMINUSBOSON
static const PdgId	Z0BOSON = 23
static const PdgId	ZBOSON = Z0BOSON
static const PdgId	Z0 = Z0BOSON
static const PdgId	HIGGSBOSON = 25
static const PdgId	HIGGS = HIGGSBOSON
Quarks
static const PdgId	DQUARK = 1
static const PdgId	UQUARK = 2
static const PdgId	SQUARK = 3
static const PdgId	CQUARK = 4
static const PdgId	BQUARK = 5
static const PdgId	TQUARK = 6
Nucleons
static const PdgId	PROTON = 2212
static const PdgId	ANTIPROTON = -PROTON
static const PdgId	PBAR = ANTIPROTON
static const PdgId	NEUTRON = 2112
static const PdgId	ANTINEUTRON = -NEUTRON
Light mesons
static const PdgId	PI0 = 111
static const PdgId	PIPLUS = 211
static const PdgId	PIMINUS = -PIPLUS
static const PdgId	K0L = 130
static const PdgId	K0S = 310
static const PdgId	KPLUS = 321
static const PdgId	KMINUS = -KPLUS
static const PdgId	ETA = 221
static const PdgId	ETAPRIME = 331
static const PdgId	PHI = 333
static const PdgId	OMEGA = 223
Charmonia
static const PdgId	ETAC = 441
static const PdgId	JPSI = 443
static const PdgId	PSI2S = 100443
Charm mesons
static const PdgId	D0 = 421
static const PdgId	DPLUS = 411
static const PdgId	DMINUS = -DPLUS
static const PdgId	DSPLUS = 431
static const PdgId	DSMINUS = -DSPLUS
Bottomonia
static const PdgId	ETAB = 551
static const PdgId	UPSILON1S = 553
static const PdgId	UPSILON2S = 100553
static const PdgId	UPSILON3S = 200553
static const PdgId	UPSILON4S = 300553
b mesons
static const PdgId	B0 = 511
static const PdgId	BPLUS = 521
static const PdgId	BMINUS = -BPLUS
static const PdgId	B0S = 531
static const PdgId	BCPLUS = 541
static const PdgId	BCMINUS = -BCPLUS
Baryons
static const PdgId	LAMBDA = 3122
static const PdgId	SIGMA0 = 3212
static const PdgId	SIGMAPLUS = 3222
static const PdgId	SIGMAMINUS = 3112
static const PdgId	LAMBDACPLUS = 4122
static const PdgId	LAMBDACMINUS = 4122
static const PdgId	LAMBDAB = 5122
static const PdgId	XI0 = 3322
static const PdgId	XIMINUS = 3312
static const PdgId	XIPLUS = -XIMINUS
static const PdgId	OMEGAMINUS = 3334
static const PdgId	OMEGAPLUS = -OMEGAMINUS
Exotic/weird stuff
static const PdgId	REGGEON = 110
static const PdgId	POMERON = 990
static const PdgId	ODDERON = 9990
static const PdgId	GRAVITON = 39
static const PdgId	NEUTRALINO1 = 1000022
static const PdgId	GRAVITINO = 1000039
static const PdgId	GLUINO = 1000021
Utility functions
enum	Location { nj = 1, nq3, nq2, nq1, nl, nr, n, n8, n9, n10 }
int	abspid (int pid)
	Absolute value (just use abs()!)
unsigned short	digit (Location loc, int pid)
	Split the PID into constituent integers.
int	extraBits (int pid)
	Returns everything beyond the 7th digit (e.g. outside the numbering scheme)
int	fundamentalID (int pid)
	Return the first two digits if this is a "fundamental" particle.

Enumeration Type Documentation

enum Location

PID digits (base 10) are: n nr nl nq1 nq2 nq3 nj The Location enum provides a convenient index into the PID.

Enumerator:

nj
nq3
nq2
nq1
nl
nr
n
n8
n9
n10

Definition at line 32 of file ParticleIdUtils.hh.

{ nj=1, nq3, nq2, nq1, nl, nr, n, n8, n9, n10 };

Function Documentation

int Rivet::PID::A ( int pid ) [inline]

Get the atomic weight (number of nucleons) in a nucleus/ion

Note:: Ion numbers are +/- 10LZZZAAAI.

Definition at line 96 of file ParticleIdUtils.hh.

References abspid(), and isNucleus().

Referenced by Rivet::diagonalize().

                          {
      // a proton can also be a Hydrogen nucleus
      if (abspid(pid) == 2212) { return 1; }
      if (isNucleus(pid)) return (abspid(pid)/10)%1000;
      return 0;
    }

int Rivet::PID::abspid ( int pid ) [inline]

Absolute value (just use abs()!)

Definition at line 26 of file ParticleIdUtils.hh.

Referenced by A(), CDF_2008_S8095620::analyze(), CDF_2006_S6653332::analyze(), ATLAS_2012_I1186556::analyze(), ATLAS_2012_CONF_2012_105::analyze(), ATLAS_2013_I1190187::analyze(), ATLAS_2012_I1180197::analyze(), ATLAS_2011_CONF_2011_090::analyze(), ATLAS_2011_S9212353::analyze(), ATLAS_2012_I943401::analyze(), digit(), extraBits(), fundamentalID(), isBaryon(), isDiquark(), isMeson(), isNucleus(), jSpin(), lambda(), threeCharge(), and Z().

                               {
      return abs(pid);
    }

double Rivet::PID::charge ( int pid ) [inline]

Return the charge (as floating point)

Definition at line 493 of file ParticleIdUtils.hh.

References threeCharge().

Referenced by CMS_2011_I954992::analyze(), CMS_2015_I1346843::analyze(), D0_2008_S7837160::analyze(), ATLAS_2014_I1298023::analyze(), ATLAS_2013_I1243871::analyze(), ATLAS_2012_I1094568::analyze(), ATLAS_2012_I1203852::analyze(), ATLAS_2012_I1204447::get_prong_number(), ATLAS_2014_I1327229::get_prong_number(), and threeCharge().

{ return threeCharge(pid)/3.0; }

unsigned short Rivet::PID::digit	(	Location	loc,
		int	pid
	)		`[inline]`

Split the PID into constituent integers.

Definition at line 35 of file ParticleIdUtils.hh.

References abspid().

Referenced by fundamentalID(), hasBottom(), hasCharm(), hasDown(), hasStrange(), hasTop(), hasUp(), isBaryon(), isDiquark(), isExcited(), isKK(), isMeson(), isNucleus(), isPentaquark(), isRhadron(), isSUSY(), isTechnicolor(), lambda(), lSpin(), sSpin(), and threeCharge().

                                                       {
      //  PID digits (base 10) are: n nr nl nq1 nq2 nq3 nj (cf. Location)
      int numerator = (int) std::pow(10.0, (loc-1));
      return (abspid(pid)/numerator) % 10;
    }

int Rivet::PID::extraBits ( int pid ) [inline]

Returns everything beyond the 7th digit (e.g. outside the numbering scheme)

Definition at line 42 of file ParticleIdUtils.hh.

References abspid().

Referenced by fundamentalID(), hasBottom(), hasCharm(), hasDown(), hasStrange(), hasTop(), hasUp(), isBaryon(), isDiquark(), isExcited(), isHadron(), isKK(), isLepton(), isMeson(), isPentaquark(), isRhadron(), isSUSY(), isTechnicolor(), isValid(), jSpin(), and threeCharge().

                                  {
      return abspid(pid)/10000000;
    }

int Rivet::PID::fundamentalID ( int pid ) [inline]

Return the first two digits if this is a "fundamental" particle.

Note:: ID = 100 is a special case (internal generator ID's are 81-100)

Definition at line 48 of file ParticleIdUtils.hh.

References abspid(), digit(), extraBits(), nq1, and nq2.

Referenced by hasBottom(), hasCharm(), hasDown(), hasStrange(), hasTop(), hasUp(), isBaryon(), isDiquark(), isLepton(), isMeson(), isSUSY(), isValid(), jSpin(), and threeCharge().

                                      {
      if (extraBits(pid) > 0) return 0;
      if (digit(nq2,pid) == 0 && digit(nq1,pid) == 0) {
        return abspid(pid) % 10000;
      } else if (abspid(pid) <= 100) {
        return abspid(pid);
      } else {
        return 0;
      }
    }

bool Rivet::PID::hasBottom ( int pid ) [inline]

Does this particle contain a bottom quark?

Definition at line 325 of file ParticleIdUtils.hh.

References digit(), extraBits(), fundamentalID(), nq1, nq2, and nq3.

Referenced by ATLAS_2012_I1118269::analyze(), LHCB_2010_I867355::analyze(), ATLAS_2012_I1188891::analyze(), ATLAS_2011_S9035664::analyze(), CMS_2013_I1256943::analyze(), ATLAS_2013_I1243871::analyze(), ATLAS_2012_I1094568::analyze(), Jet::bTags(), Jet::containsBottom(), Jet::cTags(), isBottomBaryon(), isBottomHadron(), isBottomMeson(), isCharmBaryon(), isCharmHadron(), isCharmMeson(), ATLAS_2014_I1282447::isFromBDecay(), isHeavyFlavour(), and HeavyHadrons::project().

                                   {
      if (extraBits(pid) > 0) { return false; }
      if (fundamentalID(pid) > 0) { return false; }
      if (digit(nq3,pid) == 5 || digit(nq2,pid) == 5 || digit(nq1,pid) == 5) return true;
      return false;
    }

bool Rivet::PID::hasCharm ( int pid ) [inline]

Does this particle contain a charm quark?

Definition at line 318 of file ParticleIdUtils.hh.

References digit(), extraBits(), fundamentalID(), nq1, nq2, and nq3.

Referenced by ATLAS_2012_I1188891::analyze(), Jet::containsCharm(), Jet::cTags(), ATLAS_2014_I1282447::hasCharmedChildren(), isCharmBaryon(), isCharmHadron(), isCharmMeson(), isHeavyFlavour(), and HeavyHadrons::project().

                                  {
      if (extraBits(pid) > 0) { return false; }
      if (fundamentalID(pid) > 0) { return false; }
      if (digit(nq3,pid) == 4 || digit(nq2,pid) == 4 || digit(nq1,pid) == 4) return true;
      return false;
    }

bool Rivet::PID::hasDown ( const int & pid ) [inline]

Does this particle contain a down quark?

Definition at line 304 of file ParticleIdUtils.hh.

References digit(), extraBits(), fundamentalID(), nq1, nq2, and nq3.

                                         {
      if (extraBits(pid) > 0) { return false; }
      if (fundamentalID(pid) > 0) { return false; }
      if (digit(nq3,pid) == 1 || digit(nq2,pid) == 1 || digit(nq1,pid) == 1) return true;
      return false;
    }

bool Rivet::PID::hasStrange ( int pid ) [inline]

Does this particle contain a strange quark?

Definition at line 311 of file ParticleIdUtils.hh.

References digit(), extraBits(), fundamentalID(), nq1, nq2, and nq3.

                                    {
      if (extraBits(pid) > 0) { return false; }
      if (fundamentalID(pid) > 0) { return false; }
      if (digit(nq3,pid) == 3 || digit(nq2,pid) == 3 || digit(nq1,pid) == 3) return true;
      return false;
    }

bool Rivet::PID::hasTop ( int pid ) [inline]

Does this particle contain a top quark?

Definition at line 332 of file ParticleIdUtils.hh.

References digit(), extraBits(), fundamentalID(), nq1, nq2, and nq3.

Referenced by isHeavyFlavour().

                                {
      if (extraBits(pid) > 0) { return false; }
      if (fundamentalID(pid) > 0) { return false; }
      if (digit(nq3,pid) == 6 || digit(nq2,pid) == 6 || digit(nq1,pid) == 6) return true;
      return false;
    }

bool Rivet::PID::hasUp ( const int & pid ) [inline]

Does this particle contain an up quark?

Definition at line 297 of file ParticleIdUtils.hh.

References digit(), extraBits(), fundamentalID(), nq1, nq2, and nq3.

                                       {
      if (extraBits(pid) > 0) { return false; }
      if (fundamentalID(pid) > 0) { return false; }
      if (digit(nq3,pid) == 2 || digit(nq2,pid) == 2 || digit(nq1,pid) == 2) return true;
      return false;
    }

bool Rivet::PID::isBaryon ( int pid ) [inline]

Check to see if this is a valid baryon.

Definition at line 141 of file ParticleIdUtils.hh.

References abspid(), digit(), extraBits(), fundamentalID(), nj, nq1, nq2, and nq3.

Referenced by isBottomBaryon(), isCharmBaryon(), isHadron(), isHeavyBaryon(), isLightBaryon(), and threeCharge().

                                  {
      if (extraBits(pid) > 0) { return false; }
      if (abspid(pid) <= 100) { return false; }
      if (fundamentalID(pid) <= 100 && fundamentalID(pid) > 0) { return false; }
      if (abspid(pid) == 2110 || abspid(pid) == 2210) { return true; }
      if (digit(nj,pid) > 0  && digit(nq3,pid) > 0 && digit(nq2,pid) > 0 && digit(nq1,pid) > 0) { return true; }
      return false;
    }

bool Rivet::PID::isBottomBaryon ( int pid ) [inline]

Determine if the PID is that of a b-baryon.

Definition at line 659 of file ParticleIdUtils.hh.

References hasBottom(), and isBaryon().

                                        {
      return hasBottom(pid) && isBaryon(pid);
    }

bool Rivet::PID::isBottomHadron ( int pid ) [inline]

Determine if the PID is that of a b-hadron.

Definition at line 664 of file ParticleIdUtils.hh.

References hasBottom(), and isHadron().

                                        {
      return hasBottom(pid) && isHadron(pid);
    }

bool Rivet::PID::isBottomMeson ( int pid ) [inline]

Determine if the PID is that of a b-meson.

Definition at line 654 of file ParticleIdUtils.hh.

References hasBottom(), and isMeson().

                                       {
      return hasBottom(pid) && isMeson(pid);
    }

bool Rivet::PID::isBSM ( int pid ) [inline]

Is this a BSM particle (including graviton)?

Definition at line 262 of file ParticleIdUtils.hh.

References isExcited(), isGraviton(), isKK(), isRhadron(), isSUSY(), and isTechnicolor().

Referenced by isValid().

                               {
      return isSUSY(pid) || isRhadron(pid) || isTechnicolor(pid) ||
        isExcited(pid) || isKK(pid) || isGraviton(pid);
    }

bool Rivet::PID::isCharged ( int pid ) [inline]

Determine if the particle is electrically charged.

Definition at line 502 of file ParticleIdUtils.hh.

References threeCharge().

Referenced by ATLAS_2012_I1183818::analyze().

                                   {
      return threeCharge(pid) != 0;
    }

bool Rivet::PID::isCharmBaryon ( int pid ) [inline]

Determine if the PID is that of a c-baryon.

Specifically, the _heaviest_ quark is a c: a baryon containing a b & c is a b-baryon and NOT a c-baryon. To test for the simpler case, just use a combination of hasCharm() and isBaryon().

Definition at line 682 of file ParticleIdUtils.hh.

References hasBottom(), hasCharm(), and isBaryon().

                                       {
      return isBaryon(pid) && hasCharm(pid) && !hasBottom(pid);
    }

bool Rivet::PID::isCharmHadron ( int pid ) [inline]

Determine if the PID is that of a c-hadron.

Specifically, the _heaviest_ quark is a c: a baryon containing a b & c is a b-baryon and NOT a c-baryon. To test for the simpler case, just use a combination of hasCharm() and isBaryon().

Definition at line 691 of file ParticleIdUtils.hh.

References hasBottom(), hasCharm(), and isHadron().

                                       {
      return isHadron(pid) && hasCharm(pid) && !hasBottom(pid);
    }

bool Rivet::PID::isCharmMeson ( int pid ) [inline]

Determine if the PID is that of a c-meson.

Specifically, the _heaviest_ quark is a c: a B_c is a b-meson and NOT a c-meson. Charmonia (closed charm) are counted as c-mesons here.

Definition at line 673 of file ParticleIdUtils.hh.

References hasBottom(), hasCharm(), and isMeson().

                                      {
      return isMeson(pid) && hasCharm(pid) && !hasBottom(pid);
    }

bool Rivet::PID::isChLepton ( int pid ) [inline]

Determine if the PID is that of a charged lepton.

Definition at line 548 of file ParticleIdUtils.hh.

                                    {
      const long apid = abs(pid);
      return apid == 11 || apid == 13 || apid == 15;
    }

bool Rivet::PID::isDiquark ( int pid ) [inline]

Definition at line 151 of file ParticleIdUtils.hh.

References abspid(), digit(), extraBits(), fundamentalID(), nj, nq1, nq2, and nq3.

Referenced by isDiQuark(), and isValid().

                                   {
      if (extraBits(pid) > 0) { return false; }
      if (abspid(pid) <= 100) { return false; }
      if (fundamentalID(pid) <= 100 && fundamentalID(pid) > 0) { return false; }
      if (digit(nj,pid) > 0  && digit(nq3,pid) == 0 && digit(nq2,pid) > 0 && digit(nq1,pid) > 0) {  // diquark signature
        // EvtGen uses the diquarks for quark pairs, so, for instance,
        //   5501 is a valid "diquark" for EvtGen
        //if (digit(nj) == 1 && digit(nq2) == digit(nq1)) {    // illegal
        //   return false;
        //} else {
        return true;
        //}
      }
      return false;
    }

bool Rivet::PID::isDiQuark ( int pid ) [inline]

Definition at line 166 of file ParticleIdUtils.hh.

References isDiquark().

Referenced by threeCharge().

{ return isDiquark(pid); }

bool Rivet::PID::isElectron ( int pid ) [inline]

Determine if the PID is that of an electron or positron.

Definition at line 533 of file ParticleIdUtils.hh.

References ELECTRON.

Referenced by ATLAS_2013_I1243871::analyze().

                                    {
      return abs(pid) == ELECTRON;
    }

bool Rivet::PID::isExcited ( int pid ) [inline]

Is this an excited (composite) quark or lepton?

Definition at line 244 of file ParticleIdUtils.hh.

References digit(), extraBits(), and n.

Referenced by isBSM().

                                   {
      if (extraBits(pid) > 0) { return false; }
      return digit(n,pid) == 4;
    }

bool Rivet::PID::isGenSpecific ( int pid ) [inline]

Determine if the PID is in the generator-specific range.

Definition at line 718 of file ParticleIdUtils.hh.

References Rivet::in_range().

                                       {
      return in_range(pid, 80, 101);
    }

bool Rivet::PID::isGraviton ( int pid ) [inline]

Is this a graviton?

Definition at line 257 of file ParticleIdUtils.hh.

Referenced by isBSM().

                                    {
      return pid == 39;
    }

bool Rivet::PID::isHadron ( int pid ) [inline]

Is this a valid hadron ID?

Definition at line 188 of file ParticleIdUtils.hh.

References extraBits(), isBaryon(), isMeson(), and isPentaquark().

Referenced by ATLAS_2012_I1118269::analyze(), LHCB_2010_I867355::analyze(), CMS_2010_S8656010::analyze(), ATLAS_2012_I1188891::analyze(), CMS_2010_S8547297::analyze(), ATLAS_2011_S9035664::analyze(), CMS_2011_S8884919::analyze(), EXAMPLE::analyze(), ATLAS_2013_I1243871::analyze(), ATLAS_2014_I1306615::analyze(), ATLAS_2012_I1094568::analyze(), Jet::containsBottom(), Jet::containsCharm(), ATLAS_2014_I1306615::fromHadronDecay(), LHCB_2011_I917009::getLifeTime(), LHCB_2012_I1119400::getLifeTime(), Rivet::hadronFilter(), Jet::hadronicEnergy(), isBottomHadron(), isCharmHadron(), TauFinder::isHadronic(), isHeavyHadron(), isLightHadron(), PromptFinalState::isPrompt(), isTransportable(), isValid(), Particle::isVisible(), Rivet::nonHadronFilter(), DISKinematics::project(), PrimaryHadrons::project(), and HeavyHadrons::project().

                                  {
      if (extraBits(pid) > 0) { return false; }
      if (isMeson(pid))   { return true; }
      if (isBaryon(pid))  { return true; }
      if (isPentaquark(pid)) { return true; }
      return false;
    }

bool Rivet::PID::isHeavyBaryon ( int pid ) [inline]

Determine if the PID is that of a heavy flavour (b or c) baryon.

Definition at line 628 of file ParticleIdUtils.hh.

References isBaryon(), and isHeavyFlavour().

                                       {
      return isBaryon(pid) && isHeavyFlavour(pid);
    }

bool Rivet::PID::isHeavyFlavour ( int pid ) [inline]

Determine if the particle is a heavy flavour hadron or parton.

Definition at line 602 of file ParticleIdUtils.hh.

References hasBottom(), hasCharm(), and hasTop().

Referenced by isHeavyBaryon(), isHeavyHadron(), isHeavyMeson(), isHeavyParton(), isLightBaryon(), isLightHadron(), isLightMeson(), and isLightParton().

                                        {
      return hasCharm(pid) || hasBottom(pid) || hasTop(pid);
    }

bool Rivet::PID::isHeavyHadron ( int pid ) [inline]

Determine if the PID is that of a heavy flavour (b or c) hadron.

Definition at line 633 of file ParticleIdUtils.hh.

References isHadron(), and isHeavyFlavour().

                                       {
      return isHadron(pid) && isHeavyFlavour(pid);
    }

bool Rivet::PID::isHeavyMeson ( int pid ) [inline]

Determine if the PID is that of a heavy flavour (b or c) meson.

Definition at line 623 of file ParticleIdUtils.hh.

References isHeavyFlavour(), and isMeson().

                                      {
      return isMeson(pid) && isHeavyFlavour(pid);
    }

bool Rivet::PID::isHeavyParton ( int pid ) [inline]

Determine if the PID is that of a heavy parton (c,b,t)

Definition at line 612 of file ParticleIdUtils.hh.

References isHeavyFlavour(), and isParton().

                                       {
      return isParton(pid) && isHeavyFlavour(pid);
    }

bool Rivet::PID::isHiggs ( int pid ) [inline]

Determine if the PID is that of an SM/lightest SUSY Higgs.

<

Todo:: Check on 26 still needed? (used in HERWIG SUSY, for example)

Definition at line 584 of file ParticleIdUtils.hh.

References HIGGSBOSON.

Referenced by isResonance().

                                 {
      return pid == HIGGSBOSON || pid == 26; ///< @todo Check on 26 still needed? (used in HERWIG SUSY, for example)
    }

bool Rivet::PID::isKK ( int pid ) [inline]

Is this a Kaluza-Klein excitation?

Definition at line 250 of file ParticleIdUtils.hh.

References digit(), extraBits(), and n.

Referenced by isBSM().

                              {
      if (extraBits(pid) > 0) { return false; }
      const int ndigit = digit(n,pid);
      return ndigit == 5 || ndigit == 6;
    }

bool Rivet::PID::isLepton ( int pid ) [inline]

Is this a valid lepton ID?

Definition at line 203 of file ParticleIdUtils.hh.

References extraBits(), and fundamentalID().

Referenced by ATLAS_2012_I1203852::analyze(), isTransportable(), ChargedLeptons::project(), and DISLepton::project().

                                  {
      if (extraBits(pid) > 0) { return false; }
      if (fundamentalID(pid) >= 11 && fundamentalID(pid) <= 18) { return true; }
      return false;
    }

bool Rivet::PID::isLightBaryon ( int pid ) [inline]

Determine if the PID is that of a light flavour (not b or c) baryon.

Definition at line 643 of file ParticleIdUtils.hh.

References isBaryon(), and isHeavyFlavour().

                                       {
      return isBaryon(pid) && !isHeavyFlavour(pid);
    }

bool Rivet::PID::isLightHadron ( int pid ) [inline]

Determine if the PID is that of a light flavour (not b or c) hadron.

Definition at line 648 of file ParticleIdUtils.hh.

References isHadron(), and isHeavyFlavour().

                                       {
      return isHadron(pid) && !isHeavyFlavour(pid);
    }

bool Rivet::PID::isLightMeson ( int pid ) [inline]

Determine if the PID is that of a light flavour (not b or c) meson.

Definition at line 638 of file ParticleIdUtils.hh.

References isHeavyFlavour(), and isMeson().

                                      {
      return isMeson(pid) && !isHeavyFlavour(pid);
    }

bool Rivet::PID::isLightParton ( int pid ) [inline]

Determine if the PID is that of a light parton (u,d,s)

Definition at line 617 of file ParticleIdUtils.hh.

References isHeavyFlavour(), and isParton().

                                       {
      return isParton(pid) && !isHeavyFlavour(pid);
    }

bool Rivet::PID::isMeson ( int pid ) [inline]

Check to see if this is a valid meson.

Definition at line 119 of file ParticleIdUtils.hh.

References abspid(), digit(), extraBits(), fundamentalID(), nj, nq1, nq2, and nq3.

Referenced by isBottomMeson(), isCharmMeson(), isHadron(), isHeavyMeson(), isLightMeson(), lSpin(), sSpin(), and threeCharge().

                                 {
      if (extraBits(pid) > 0) { return false; }
      if (abspid(pid) <= 100) { return false; }
      if (fundamentalID(pid) <= 100 && fundamentalID(pid) > 0) { return false; }
      int aid = abspid(pid);
      if (aid == 130 || aid == 310 || aid == 210) { return true; }
      // EvtGen uses some odd numbers
      if (aid == 150 || aid == 350 || aid == 510 || aid == 530) { return true; }
      // pomeron, etc.
      if (pid == 110 || pid == 990 || pid == 9990) { return true; }
      if (digit(nj,pid) > 0 && digit(nq3,pid) > 0 && digit(nq2,pid) > 0 && digit(nq1,pid) == 0) {
        // check for illegal antiparticles
        if (digit(nq3,pid) == digit(nq2,pid) && pid < 0) {
          return false;
        } else {
          return true;
        }
      }
      return false;
    }

bool Rivet::PID::isMuon ( int pid ) [inline]

Determine if the PID is that of an muon or antimuon.

Definition at line 538 of file ParticleIdUtils.hh.

References MUON.

Referenced by FastJets::project().

                                {
      return abs(pid) == MUON;
    }

bool Rivet::PID::isNeutral ( int pid ) [inline]

Determine if the particle is electrically neutral.

Definition at line 507 of file ParticleIdUtils.hh.

References threeCharge().

                                   {
      return threeCharge(pid) == 0;
    }

bool Rivet::PID::isNeutrino ( int pid ) [inline]

Determine if the PID is that of a neutrino.

Definition at line 554 of file ParticleIdUtils.hh.

                                    {
      const long apid = abs(pid);
      return apid == 12 || apid == 14 || apid == 16;
    }

bool Rivet::PID::isNucleus ( int pid ) [inline]

Is this a nucleus PID?

This implements the 2006 Monte Carlo nuclear code scheme. Ion numbers are +/- 10LZZZAAAI. AAA is A - total baryon number ZZZ is Z - total charge L is the total number of strange quarks. I is the isomer number, with I=0 corresponding to the ground state.

Definition at line 73 of file ParticleIdUtils.hh.

References abspid(), digit(), n10, and n9.

Referenced by A(), isValid(), lambda(), and Z().

                                   {
      // a proton can also be a Hydrogen nucleus
      if (abspid(pid) == 2212) { return true; }
      // new standard: +/- 10LZZZAAAI
      if ((digit(n10,pid) == 1) && (digit(n9,pid) == 0)) {
        // charge should always be less than or equal to baryon number
        // the following line is A >= Z
        if ((abspid(pid)/10)%1000 >= (abspid(pid)/10000)%1000) { return true; }
      }
      return false;
    }

bool Rivet::PID::isParton ( int pid ) [inline]

Determine if the PID is that of a parton (quark or gluon)

Definition at line 523 of file ParticleIdUtils.hh.

References GLUON, and isQuark().

Referenced by FinalPartons::accept(), isHeavyParton(), isLightParton(), and PromptFinalState::isPrompt().

                                  {
      return pid == GLUON || isQuark(pid);
    }

bool Rivet::PID::isPentaquark ( int pid ) [inline]

Check to see if this is a valid pentaquark.

Definition at line 169 of file ParticleIdUtils.hh.

References digit(), extraBits(), n, nj, nl, nq1, nq2, nq3, and nr.

Referenced by isHadron().

                                      {
      // a pentaquark is of the form 9abcdej,
      // where j is the spin and a, b, c, d, and e are quarks
      if (extraBits(pid) > 0) { return false; }
      if (digit(n,pid) != 9)  { return false; }
      if (digit(nr,pid) == 9 || digit(nr,pid) == 0)  { return false; }
      if (digit(nj,pid) == 9 || digit(nl,pid) == 0)  { return false; }
      if (digit(nq1,pid) == 0)  { return false; }
      if (digit(nq2,pid) == 0)  { return false; }
      if (digit(nq3,pid) == 0)  { return false; }
      if (digit(nj,pid) == 0)  { return false; }
      // check ordering
      if (digit(nq2,pid) > digit(nq1,pid))  { return false; }
      if (digit(nq1,pid) > digit(nl,pid))  { return false; }
      if (digit(nl,pid) > digit(nr,pid))  { return false; }
      return true;
    }

bool Rivet::PID::isPhoton ( int pid ) [inline]

Determine if the PID is that of a photon.

Definition at line 528 of file ParticleIdUtils.hh.

References PHOTON.

Referenced by isTransportable().

                                  {
      return pid == PHOTON;
    }

bool Rivet::PID::isQuark ( int pid ) [inline]

Determine if the PID is that of a quark.

Definition at line 518 of file ParticleIdUtils.hh.

References Rivet::in_closed_range().

Referenced by isParton().

                                 {
      return in_closed_range(abs(pid), 1, 6);
    }

bool Rivet::PID::isReggeon ( int pid ) [inline]

Is this a pomeron, odderon, or generic reggeon?

Definition at line 268 of file ParticleIdUtils.hh.

                                   {
      return pid == 110 || pid == 990 || pid == 9990;
    }

bool Rivet::PID::isResonance ( int pid ) [inline]

Determine if the PID is that of an EW scale resonance

Todo:: Also include SUSY, technicolor, etc. etc.? Maybe via a isStandardModel(pid) function, but there are stable BSM particles (in principle)

Definition at line 725 of file ParticleIdUtils.hh.

References isHiggs(), isTop(), isW(), and isZ().

                                     {
      return isW(pid) || isZ(pid) || isHiggs(pid) || isTop(pid);
    }

bool Rivet::PID::isRhadron ( int pid ) [inline]

Is this an R-hadron?

Definition at line 221 of file ParticleIdUtils.hh.

References digit(), extraBits(), isSUSY(), n, nj, nq2, nq3, and nr.

Referenced by isBSM(), and isRHadron().

                                   {
      // an R-hadron is of the form 10abcdj,
      // where j is the spin and a, b, c, and d are quarks or gluons
      if (extraBits(pid) > 0) { return false; }
      if (digit(n,pid) != 1)  { return false; }
      if (digit(nr,pid) != 0)  { return false; }
      // make sure this isn't a SUSY particle
      if (isSUSY(pid)) { return false; }
      // All R-hadrons have at least 3 core digits
      if (digit(nq2,pid) == 0)  { return false; }
      if (digit(nq3,pid) == 0)  { return false; }
      if (digit(nj,pid) == 0)  { return false; }
      return true;
    }

bool Rivet::PID::isRHadron ( int pid ) [inline]

Definition at line 235 of file ParticleIdUtils.hh.

References isRhadron().

{ return isRhadron(pid); }

bool Rivet::PID::isSUSY ( int pid ) [inline]

Is this a fundamental SUSY particle?

Definition at line 210 of file ParticleIdUtils.hh.

References digit(), extraBits(), fundamentalID(), n, and nr.

Referenced by isBSM(), and isRhadron().

                                {
      // fundamental SUSY particles have n = 1 or 2
      if (extraBits(pid) > 0) { return false; }
      if (digit(n,pid) != 1 && digit(n,pid) != 2)  { return false; }
      if (digit(nr,pid) != 0)  { return false; }
      // check fundamental part
      if (fundamentalID(pid) == 0)  { return false; }
      return true;
    }

bool Rivet::PID::isTau ( int pid ) [inline]

Determine if the PID is that of an tau or antitau.

Definition at line 543 of file ParticleIdUtils.hh.

References TAU.

Referenced by Jet::tauTags().

                               {
      return abs(pid) == TAU;
    }

bool Rivet::PID::isTechnicolor ( int pid ) [inline]

Is this a technicolor particle?

Definition at line 238 of file ParticleIdUtils.hh.

References digit(), extraBits(), and n.

Referenced by isBSM().

                                       {
      if (extraBits(pid) > 0) { return false; }
      return digit(n,pid) == 3;
    }

bool Rivet::PID::isTop ( int pid ) [inline]

Determine if the PID is that of a t/tbar.

Todo:: isSUSYHiggs?

Definition at line 591 of file ParticleIdUtils.hh.

Referenced by isResonance().

                               {
      return abs(pid) == 6;
    }

bool Rivet::PID::isTransportable ( int pid ) [inline]

Check the PID for usability in transport codes like Geant4

Todo:: Should exclude neutrinos/LSP, since the ATLAS G4 interface deletes them immediately?

Definition at line 732 of file ParticleIdUtils.hh.

References isHadron(), isLepton(), and isPhoton().

                                         {
      // return !isResonance(pid) && !isParton(pid) && !isGenSpecific(pid);
      return isPhoton(pid) || isHadron(pid) || isLepton(pid);
    }

bool Rivet::PID::isValid ( int pid ) [inline]

Check to see if this is a valid PID (i.e. matches any known scheme)

Definition at line 273 of file ParticleIdUtils.hh.

References extraBits(), fundamentalID(), isBSM(), isDiquark(), isHadron(), and isNucleus().

                                 {
      if (extraBits(pid) > 0) {
        if (isNucleus(pid)) return true;
        return false;
      }
      if (isBSM(pid)) return true;
      if (isHadron(pid)) return true;
      if (isDiquark(pid)) return true;
      if (fundamentalID(pid) > 0) {
        return true;
        // AB - disabled this to remove need for PID -> name lookup.
        // if (pid > 0) return true; else return hasFundamentalAnti(pid);
      }
      // Don't recognize this number
      return false;
    }

bool Rivet::PID::isW ( int pid ) [inline]

Determine if the PID is that of a W+-.

Definition at line 574 of file ParticleIdUtils.hh.

References WPLUSBOSON.

Referenced by isResonance().

                             {
      return abs(pid) == WPLUSBOSON;
    }

bool Rivet::PID::isWminus ( int pid ) [inline]

Determine if the PID is that of a W-.

Definition at line 569 of file ParticleIdUtils.hh.

References WMINUSBOSON.

                                  {
      return pid == WMINUSBOSON;
    }

bool Rivet::PID::isWplus ( int pid ) [inline]

Determine if the PID is that of a W+.

Todo:: Add isElectron, Muon, Tau (and +- specific versions?)... and is(Anti)Proton?

Definition at line 564 of file ParticleIdUtils.hh.

References WPLUSBOSON.

                                 {
      return pid == WPLUSBOSON;
    }

bool Rivet::PID::isZ ( int pid ) [inline]

Determine if the PID is that of a Z0.

Definition at line 579 of file ParticleIdUtils.hh.

References Z0BOSON.

Referenced by ATLAS_2014_I1312627::fillPlots(), and isResonance().

                             {
      return pid == Z0BOSON;
    }

int Rivet::PID::jSpin ( int pid ) [inline]

jSpin returns 2J+1, where J is the total spin

Definition at line 346 of file ParticleIdUtils.hh.

References abspid(), extraBits(), and fundamentalID().

                              {
      if (fundamentalID(pid) > 0) {
        // some of these are known
        int fund = fundamentalID(pid);
        if (fund > 0 && fund < 7) return 2;
        if (fund == 9) return 3;
        if (fund > 10 && fund < 17) return 2;
        if (fund > 20 && fund < 25) return 3;
        return 0;
      } else if (extraBits(pid) > 0) {
        return 0;
      }
      return abspid(pid)%10;
    }

int Rivet::PID::lambda ( int pid ) [inline]

If this is a nucleus (ion), get nLambda

Note:: Ion numbers are +/- 10LZZZAAAI.

Definition at line 105 of file ParticleIdUtils.hh.

References abspid(), digit(), isNucleus(), and n8.

                               {
      // a proton can also be a Hydrogen nucleus
      if (abspid(pid) == 2212) { return 0; }
      if (isNucleus(pid)) return digit(n8,pid);
      return 0;
    }

int Rivet::PID::lSpin ( int pid ) [inline]

lSpin returns 2L+1, where L is the orbital angular momentum

Definition at line 387 of file ParticleIdUtils.hh.

References digit(), isMeson(), n, nj, and nl.

                              {
      if (!isMeson(pid)) { return 0; }
      int inl = digit(nl,pid);
      //int tent = digit(n,pid);
      int js = digit(nj,pid);
      if (digit(n,pid) == 9) { return 0; } // tentative ID
      if (inl == 0 && js == 3) {
        return 0;
      } else if (inl == 0 && js == 5) {
        return 1;
      } else if (inl == 0 && js == 7) {
        return 2;
      } else if (inl == 0 && js == 9) {
        return 3;
      } else if (inl == 0  && js == 1) {
        return 0;
      } else if (inl == 1  && js == 3) {
        return 1;
      } else if (inl == 1  && js == 5) {
        return 2;
      } else if (inl == 1  && js == 7) {
        return 3;
      } else if (inl == 1  && js == 9) {
        return 4;
      } else if (inl == 2  && js == 3) {
        return 1;
      } else if (inl == 2  && js == 5) {
        return 2;
      } else if (inl == 2  && js == 7) {
        return 3;
      } else if (inl == 2  && js == 9) {
        return 4;
      } else if (inl == 1  && js == 1) {
        return 1;
      } else if (inl == 3  && js == 3) {
        return 2;
      } else if (inl == 3  && js == 5) {
        return 3;
      } else if (inl == 3  && js == 7) {
        return 4;
      } else if (inl == 3  && js == 9) {
        return 5;
      }
      // Default to zero
      return 0;
    }

std::pair<PdgId,PdgId> Rivet::PID::make_pdgid_pair	(	PdgId	a,
		PdgId	b
	)		`[inline]`

Convenience maker of particle ID pairs from PdgIds.

Definition at line 233 of file ParticleName.hh.

Referenced by Rivet::compatible(), and AnalysisInfo::make().

                                                                  {
      return make_pair(a, b);
    }

std::pair<PdgId,PdgId> Rivet::PID::make_pdgid_pair	(	const std::string &	a,
		const std::string &	b
	)		`[inline]`

Convenience maker of particle ID pairs from particle names.

Definition at line 239 of file ParticleName.hh.

References toParticleId().

                                                                                        {
      const PdgId pa = toParticleId(a);
      const PdgId pb = toParticleId(b);
      return make_pair(pa, pb);
    }

int Rivet::PID::sSpin ( int pid ) [inline]

sSpin returns 2S+1, where S is the spin

Definition at line 362 of file ParticleIdUtils.hh.

References digit(), isMeson(), n, nj, and nl.

                               {
      if (!isMeson(pid)) { return 0; }
      int inl = digit(nl,pid);
      //int tent = digit(n,pid);
      int js = digit(nj,pid);
      if (digit(n,pid) == 9) { return 0; } // tentative ID
      //if (tent == 9) { return 0; }   // tentative assignment
      if (inl == 0 && js >= 3) {
        return 1;
      } else if (inl == 0  && js == 1) {
        return 0;
      } else if (inl == 1  && js >= 3) {
        return 0;
      } else if (inl == 2  && js >= 3) {
        return 1;
      } else if (inl == 1  && js == 1) {
        return 1;
      } else if (inl == 3  && js >= 3) {
        return 1;
      }
      // Default to zero
      return 0;
    }

int Rivet::PID::threeCharge ( int pid ) [inline]

Three times the charge (as integer)

Definition at line 441 of file ParticleIdUtils.hh.

References abspid(), charge(), digit(), extraBits(), fundamentalID(), isBaryon(), isDiQuark(), isMeson(), nj, nq1, nq2, and nq3.

Referenced by H1_1994_S2919893::analyze(), D0_2015_I1324946::analyze(), D0_2010_S8821313::analyze(), ATLAS_2014_I1298811::analyze(), MC_WINC::analyze(), ATLAS_2012_I1126136::analyze(), ATLAS_2012_I1183818::analyze(), MC_WPOL::analyze(), ATLAS_2013_I1190187::analyze(), ATLAS_2012_I1095236::analyze(), ATLAS_2012_CONF_2012_109::analyze(), MC_SUSY::analyze(), ATLAS_2014_I1306615::analyze(), charge(), ATLAS_2011_I944826::daughtersSurviveCuts(), isCharged(), isNeutral(), Particle::isVisible(), Jet::neutralEnergy(), ChargedFinalState::project(), NeutralFinalState::project(), DressedLeptons::project(), ZFinder::project(), and WFinder::project().

                                    {
      int charge=0;
      int ida, sid;
      unsigned short q1, q2, q3;
      static int ch100[100] = { -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, 0, 0, 0,
                                0, -1, 0, 0, 0, 0, 0, 0, 0, 0,
                                0, 6, 3, 6, 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 };
      q1 = digit(nq1,pid);
      q2 = digit(nq2,pid);
      q3 = digit(nq3,pid);
      ida = abspid(pid);
      sid = fundamentalID(pid);
      if (ida == 0 || extraBits(pid) > 0) {      // ion or illegal
        return 0;
      } else if (sid > 0 && sid <= 100) {  // use table
        charge = ch100[sid-1];
        if(ida==1000017 || ida==1000018) { charge = 0; }
        if(ida==1000034 || ida==1000052) { charge = 0; }
        if(ida==1000053 || ida==1000054) { charge = 0; }
        if(ida==5100061 || ida==5100062) { charge = 6; }
      } else if (digit(nj,pid) == 0) {         // KL, Ks, or undefined
        return 0;
      } else if (isMeson(pid)) {           // mesons
        if (q2 == 3 || q2 == 5) {
          charge = ch100[q3-1] - ch100[q2-1];
        } else {
          charge = ch100[q2-1] - ch100[q3-1];
        }
      } else if (isDiQuark(pid)) {         // diquarks
        charge = ch100[q2-1] + ch100[q1-1];
      } else if (isBaryon(pid)) {          // baryons
        charge = ch100[q3-1] + ch100[q2-1] + ch100[q1-1];
      } else {      // unknown
        return 0;
      }
      if (charge == 0) {
        return 0;
      } else if (pid < 0) {
        charge = -charge;
      }
      return charge;
    }

std::string Rivet::PID::toBeamsString ( const PdgIdPair & pair ) [inline]

Print a PdgIdPair as a string.

Definition at line 247 of file ParticleName.hh.

References toParticleName().

Referenced by AnalysisHandler::analyze().

                                                          {
      string out = "[" +
        toParticleName(pair.first) + ", " +
        toParticleName(pair.second) + "]";
      return out;
    }

PdgId Rivet::PID::toParticleId ( const std::string & pname ) [inline]

Print a PdgId as a named string.

Definition at line 227 of file ParticleName.hh.

References ParticleNames::particleId().

Referenced by make_pdgid_pair().

                                                      {
      return ParticleNames::particleId(pname);
    }

const std::string& Rivet::PID::toParticleName ( PdgId p ) [inline]

Print a PdgId as a named string.

Definition at line 221 of file ParticleName.hh.

References ParticleNames::particleName().

Referenced by Rivet::to_str(), and toBeamsString().

                                                    {
      return ParticleNames::particleName(p);
    }

int Rivet::PID::Z ( int pid ) [inline]

Get the atomic number (number of protons) in a nucleus/ion

Note:: Ion numbers are +/- 10LZZZAAAI.

Definition at line 87 of file ParticleIdUtils.hh.

References abspid(), and isNucleus().

                          {
      // A proton can also be a Hydrogen nucleus
      if (abspid(pid) == 2212) { return 1; }
      if (isNucleus(pid)) return (abspid(pid)/10000)%1000;
      return 0;
    }