9 #ifndef RIVET_PARTICLEIDUTILS_HH 10 #define RIVET_PARTICLEIDUTILS_HH 15 #include "Rivet/Tools/ParticleName.hh" 16 #include "Rivet/Math/MathUtils.hh" 31 enum Location { nj=1, nq3, nq2, nq1, nl, nr, n, n8, n9, n10 };
34 inline unsigned short _digit(
Location loc,
int pid) {
36 int numerator = (int) std::pow(10.0, (loc-1));
37 return (abs(pid)/numerator) % 10;
41 inline int _extraBits(
int pid) {
42 return abs(pid)/10000000;
47 inline int _fundamentalID(
int pid) {
48 if (_extraBits(pid) > 0)
return 0;
49 if (_digit(nq2,pid) == 0 && _digit(nq1,pid) == 0) {
50 return abs(pid) % 10000;
51 }
else if (abs(pid) <= 100) {
62 inline bool isBSM(
int pid);
78 if (abs(pid) == 2212)
return true;
80 if (_digit(n10,pid) == 1 && _digit(n9,pid) == 0) {
83 if ((abs(pid)/10) % 1000 >= (abs(pid)/10000) % 1000)
return true;
92 if (abs(pid) == 2212) {
return 1; }
93 if (
isNucleus(pid))
return (abs(pid)/10000) % 1000;
101 if (abs(pid) == 2212) {
return 1; }
102 if (
isNucleus(pid))
return (abs(pid)/10) % 1000;
110 if (abs(pid) == 2212) {
return 0; }
111 if (
isNucleus(pid))
return _digit(n8,pid);
139 return pid == PHOTON;
144 return abs(pid) == ELECTRON;
149 return abs(pid) == MUON;
154 return abs(pid) == TAU;
159 const long apid = abs(pid);
160 return apid == 11 || apid == 13 || apid == 15 || apid == 17;
168 const long apid = abs(pid);
169 return apid == 12 || apid == 14 || apid == 16 || apid == 18;
175 return pid == WPLUSBOSON;
180 return pid == WMINUSBOSON;
184 inline bool isW(
int pid) {
185 return abs(pid) == WPLUSBOSON;
189 inline bool isZ(
int pid) {
190 return pid == Z0BOSON;
195 return pid == HIGGSBOSON || pid == 26;
203 return pid == GRAVITON;
214 inline bool isStrange(
int pid) {
return abs(pid) == SQUARK; }
217 inline bool isCharm(
int pid) {
return abs(pid) == CQUARK; }
220 inline bool isBottom(
int pid) {
return abs(pid) == BQUARK; }
223 inline bool isTop(
int pid) {
return abs(pid) == TQUARK; }
233 return pid == 110 || pid == 990 || pid == 9990;
238 if (_extraBits(pid) > 0)
return false;
239 if (
isBSM(pid))
return false;
240 const int aid = abs(pid);
241 if (aid == 130 || aid == 310 || aid == 210)
return true;
242 if (aid <= 100)
return false;
243 if (_digit(nq1,pid) != 0)
return false;
244 if (_digit(nq2,pid) == 0)
return false;
245 if (_digit(nq3,pid) == 0)
return false;
246 if (_digit(nq2,pid) < _digit(nq3,pid))
return false;
249 if (aid == 150 || aid == 350 || aid == 510 || aid == 530)
return true;
253 if (_digit(nj,pid) > 0 && _digit(nq3,pid) > 0 && _digit(nq2,pid) > 0 && _digit(nq1,pid) == 0) {
254 return !(_digit(nq3,pid) == _digit(nq2,pid) && pid < 0);
261 if (_extraBits(pid) > 0)
return false;
262 if (
isBSM(pid))
return false;
263 if (abs(pid) <= 100)
return false;
264 if (_fundamentalID(pid) <= 100 && _fundamentalID(pid) > 0)
return false;
265 if (abs(pid) == 2110 || abs(pid) == 2210)
return true;
266 if (_digit(nj,pid) == 0)
return false;
267 if (_digit(nq1,pid) == 0 || _digit(nq2,pid) == 0 || _digit(nq3,pid) == 0)
return false;
278 inline bool isDiquark(
int pid) {
279 if (_extraBits(pid) > 0)
return false;
280 if (
isBSM(pid))
return false;
281 if (abs(pid) <= 100)
return false;
282 if (_fundamentalID(pid) <= 100 && _fundamentalID(pid) > 0)
return false;
283 if (_digit(nq1,pid) == 0)
return false;
284 if (_digit(nq2,pid) == 0)
return false;
285 if (_digit(nq3,pid) != 0)
return false;
286 if (_digit(nq1,pid) < _digit(nq2,pid))
return false;
287 if (_digit(nj,pid) > 0 && _digit(nq3,pid) == 0 && _digit(nq2,pid) > 0 && _digit(nq1,pid) > 0)
return true;
297 inline bool isDiQuark(
int pid) {
return isDiquark(pid); }
303 if (_extraBits(pid) > 0)
return false;
304 if (
isBSM(pid))
return false;
305 if (_digit(n,pid) != 9)
return false;
306 if (_digit(nr,pid) == 9 || _digit(nr,pid) == 0)
return false;
307 if (_digit(nj,pid) == 9 || _digit(nl,pid) == 0)
return false;
308 if (_digit(nq1,pid) == 0)
return false;
309 if (_digit(nq2,pid) == 0)
return false;
310 if (_digit(nq3,pid) == 0)
return false;
311 if (_digit(nj,pid) == 0)
return false;
313 if (_digit(nq2,pid) > _digit(nq1,pid))
return false;
314 if (_digit(nq1,pid) > _digit(nl,pid))
return false;
315 if (_digit(nl,pid) > _digit(nr,pid))
return false;
323 if (_extraBits(pid) > 0)
return false;
324 if (
isBSM(pid) > 0)
return false;
341 if (_extraBits(pid) > 0)
return false;
342 if (
isBSM(pid) > 0)
return false;
343 if (_fundamentalID(pid) >= 11 && _fundamentalID(pid) <= 18)
return true;
364 if (_extraBits(pid) > 0)
return false;
365 if (_digit(n,pid) != 1 && _digit(n,pid) != 2)
return false;
366 if (_digit(nr,pid) != 0)
return false;
368 const int fundId = _fundamentalID(pid);
369 if (fundId == 0)
return false;
370 if (_digit(n,pid) == 1) {
372 }
else if (_digit(n,pid) == 2) {
382 if (_extraBits(pid) > 0)
return false;
383 if (_digit(n,pid) != 1)
return false;
384 if (_digit(nr,pid) != 0)
return false;
386 if (
isSUSY(pid))
return false;
388 if (_digit(nq2,pid) == 0)
return false;
389 if (_digit(nq3,pid) == 0)
return false;
390 if (_digit(nj,pid) == 0)
return false;
398 if (_extraBits(pid) > 0)
return false;
399 return _digit(n,pid) == 3;
404 if (_extraBits(pid) > 0)
return false;
405 return _digit(n,pid) == 4 && _digit(nr,pid) == 0;
410 if (_extraBits(pid) > 0)
return false;
411 const int ndigit = _digit(n,pid);
412 return ndigit == 5 || ndigit == 6;
426 const int ndigit = _digit(n,pid);
427 const int nrdigit = _digit(nr,pid);
428 if ((ndigit == 0 && nrdigit == 0) || (ndigit == 5 && nrdigit == 9))
439 return (_digit(n,pid) == 4 && _digit(nr,pid) == 9);
452 return abs(pid) == BPRIME || abs(pid) == TPRIME || abs(pid) == LPRIME || abs(pid) == NUPRIME;
457 if (_digit(n,pid) != 4)
return false;
458 if (_digit(nr,pid) != 1)
return false;
459 if (_digit(nl,pid) != 1 && _digit(nl,pid) != 2)
return false;
461 if (_digit(nq3,pid) == 0) {
return false; }
463 if (_digit(nj,pid) != 0)
return false;
474 if (_extraBits(pid) != 1)
return false;
475 if (_digit(n,pid) != 0)
return false;
476 if (_digit(nr,pid) != 0)
return false;
478 if ((abs(pid)/10) % 10000 == 0)
return false;
480 if (_digit(nj,pid) != 0)
return false;
491 return isLepton( _fundamentalID(pid) );
495 inline bool isBlackHole(
int pid) {
496 if (_digit(n,pid) != 5 && _digit(n,pid) != 6)
return false;
497 if (_digit(nl,pid) != 0)
return false;
498 return _fundamentalID(pid)==40;
503 if (_digit( n,pid) != 1)
return false;
504 if (_digit(nr,pid) != 0)
return false;
505 if (_digit(nl,pid) != 0)
return false;
506 if (_digit(nj,pid) != 0)
return false;
520 inline bool _isValid(
int pid) {
522 if (_digit(n, pid) == 9 && _digit(nr, pid) == 9)
return true;
526 if (
isBSM(pid))
return true;
528 if (_digit(n,pid) == 9 && _digit(nr,pid) == 0)
return false;
529 if (isDiquark(pid))
return true;
536 return (_fundamentalID(pid) > 0);
538 inline bool isValid(
int pid) {
return _isValid(pid); }
546 inline bool _hasQ(
int pid,
int q) {
547 if (abs(pid) == q)
return true;
548 if (!_isValid(pid))
return false;
554 for (
int i = 6; i > 1; --i) {
555 if (_digit(
Location(i), pid) == 0) {
557 }
else if ( i == iz-1 ) {
560 if (_digit(
Location(i),pid) == q)
return true;
565 if (_digit(nq3,pid) == q || _digit(nq2,pid) == q || _digit(nq1,pid) == q )
return true;
567 if (_digit(nl,pid) == q || _digit(nr,pid) == q)
return true;
726 const int fund = _fundamentalID(pid);
729 if (fund > 0 && fund < 7)
return 2;
730 if (fund == 9)
return 3;
731 if (fund > 10 && fund < 17)
return 2;
732 if (fund > 20 && fund < 25)
return 3;
734 }
else if (_extraBits(pid) > 0) {
737 return abs(pid) % 10;
744 if (_digit(n,pid) == 9 && _digit(nr,pid) == 0)
return 0;
746 const int fund = _fundamentalID(pid);
747 if (fund == 51 || fund == 54)
return 1;
748 if (fund == 52)
return 2;
749 if (fund == 53 || fund == 55)
return 3;
751 const int inl = _digit(nl,pid);
752 const int js = _digit(nj,pid);
753 if (inl == 0 && js >= 3)
return 1;
754 else if (inl == 0 && js == 1)
return 0;
755 else if (inl == 1 && js >= 3)
return 0;
756 else if (inl == 2 && js >= 3)
return 1;
757 else if (inl == 1 && js == 1)
return 1;
758 else if (inl == 3 && js >= 3)
return 1;
767 if (_digit(n,pid) == 9 && _digit(nr,pid) == 0)
return 0;
769 const int inl = _digit(nl,pid);
770 const int js = _digit(nj,pid);
771 if (inl == 0 && js == 3)
return 0;
772 else if (inl == 0 && js == 5)
return 1;
773 else if (inl == 0 && js == 7)
return 2;
774 else if (inl == 0 && js == 9)
return 3;
775 else if (inl == 0 && js == 1)
return 0;
776 else if (inl == 1 && js == 3)
return 1;
777 else if (inl == 1 && js == 5)
return 2;
778 else if (inl == 1 && js == 7)
return 3;
779 else if (inl == 1 && js == 9)
return 4;
780 else if (inl == 2 && js == 3)
return 1;
781 else if (inl == 2 && js == 5)
return 2;
782 else if (inl == 2 && js == 7)
return 3;
783 else if (inl == 2 && js == 9)
return 4;
784 else if (inl == 1 && js == 1)
return 1;
785 else if (inl == 3 && js == 3)
return 2;
786 else if (inl == 3 && js == 5)
return 3;
787 else if (inl == 3 && js == 7)
return 4;
788 else if (inl == 3 && js == 9)
return 5;
801 static int ch100[100] = { -1, 2, -1, 2, -1, 2, -1, 2, 0, 0,
802 -3, 0, -3, 0, -3, 0, -3, 0, 0, 0,
803 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
804 0, 0, 0, 3, 0, 0, 3, 0, 0, 0,
805 0, -1, 0, 0, 0, 0, 0, 0, 0, 0,
806 0, 6, 3, 6, 0, 0, 0, 0, 0, 0,
807 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
808 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
809 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
810 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
811 const unsigned short q1 = _digit(nq1,pid);
812 const unsigned short q2 = _digit(nq2,pid);
813 const unsigned short q3 = _digit(nq3,pid);
814 const unsigned short ql = _digit(nl,pid);
815 const int ida = abs(pid);
816 const int sid = _fundamentalID(pid);
818 if (ida == 0 || _extraBits(pid) > 0) {
821 ch3 = 3*( (ida/10) % 10000);
824 }
else if(
isDyon(pid) ) {
825 ch3 = 3*( (ida/10) % 1000) * (ql == 2 ? -1 : 1);
826 }
else if (sid > 0 && sid <= 100) {
827 if (ida == 1000017 || ida == 1000018 || ida == 1000034) ch3 = 0;
828 else if (ida > 1000050 && ida <= 1000060) ch3 = 0;
829 else if (ida > 50 && ida <= 60) ch3 = 0;
830 else if (ida == 5100061 || ida == 5100062) ch3 = 6;
831 else ch3 = ch100[sid-1];
832 }
else if (_digit(nj,pid) == 0) {
835 ch3 = ((q2 == 3 || q2 == 5) ? -1 : 1) * (ch100[q2-1] - ch100[q3-1]);
838 if (q1 == 0 || q1 == 9) {
839 if (q2 == 3 || q2 == 5) {
840 ch3 = ch100[q3-1] - ch100[q2-1];
842 ch3 = ch100[q2-1] - ch100[q3-1];
844 }
else if (ql == 0) {
845 ch3 = ch100[q3-1] + ch100[q2-1] + ch100[q1-1];
846 }
else if (_digit(nr,pid) == 0) {
847 ch3 = ch100[q3-1] + ch100[q2-1] + ch100[q1-1] + ch100[ql-1];
850 ch3 = ch100[q2-1] + ch100[q1-1];
852 ch3 = ch100[q3-1] + ch100[q2-1] + ch100[q1-1];
856 if (pid < 0) ch3 *= -1;
947 inline bool isSameSign(PdgId a, PdgId b) {
return a*b >= 0; }
948 inline bool isOppSign(PdgId a, PdgId b) {
return !isSameSign(a, b); }
949 inline bool isSameFlav(PdgId a, PdgId b) {
return abs(a) == abs(b); }
950 inline bool isOppFlav(PdgId a, PdgId b) {
return !isSameFlav(a, b); }
952 inline bool isOSSF(PdgId a, PdgId b) {
return isOppSign(a, b) && isSameFlav(a, b); }
953 inline bool isSSSF(PdgId a, PdgId b) {
return isSameSign(a, b) && isSameFlav(a, b); }
954 inline bool isOSOF(PdgId a, PdgId b) {
return isOppSign(a, b) && isOppFlav(a, b); }
955 inline bool isSSOF(PdgId a, PdgId b) {
return isSameSign(a, b) && isOppFlav(a, b); }
bool isGluon(int pid)
Determine if the PID is that of a gluon.
Definition: ParticleIdUtils.hh:127
Definition: MC_Cent_pPb.hh:10
int abscharge3(int pid)
Return the absolute value of 3 times the EM charge.
Definition: ParticleIdUtils.hh:865
bool isLightBaryon(int pid)
Determine if the PID is that of a light flavour (not b or c) baryon.
Definition: ParticleIdUtils.hh:634
bool isBottomBaryon(int pid)
Determine if the PID is that of a b-baryon.
Definition: ParticleIdUtils.hh:650
int nuclA(int pid)
Definition: ParticleIdUtils.hh:99
bool isPhoton(int pid)
Determine if the PID is that of a photon.
Definition: ParticleIdUtils.hh:138
bool hasDown(int pid)
Does this particle contain a down quark?
Definition: ParticleIdUtils.hh:573
bool isHiggs(int pid)
Determine if the PID is that of an SM/lightest SUSY Higgs.
Definition: ParticleIdUtils.hh:194
bool isElectron(int pid)
Determine if the PID is that of an electron or positron.
Definition: ParticleIdUtils.hh:143
bool isTechnicolor(int pid)
Is this a technicolor particle?
Definition: ParticleIdUtils.hh:397
bool isDiQuark(int pid)
Definition: ParticleIdUtils.hh:297
bool isParton(int pid)
Determine if the PID is that of a parton (quark or gluon)
Definition: ParticleIdUtils.hh:132
bool hasUp(int pid)
Does this particle contain an up quark?
Definition: ParticleIdUtils.hh:575
bool isNeutral(int pid)
Determine if the particle is electrically neutral.
Definition: ParticleIdUtils.hh:885
bool isBSMBoson(int pid)
Is this a valid BSM boson (SUSY Higgs, W', Z')?
Definition: ParticleIdUtils.hh:348
int threeCharge(int pid)
Definition: ParticleIdUtils.hh:862
bool isStrange(int pid)
Determine if the PID is that of an s/sbar.
Definition: ParticleIdUtils.hh:214
std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type in_range(N1 val, N2 low, N3 high)
Boolean function to determine if value is within the given range.
Definition: MathUtils.hh:163
bool isWminus(int pid)
Determine if the PID is that of a W-.
Definition: ParticleIdUtils.hh:179
bool isBSM(int pid)
Is this a BSM particle (including graviton)?
Definition: ParticleIdUtils.hh:511
bool isHeavyBaryon(int pid)
Determine if the PID is that of a heavy flavour (b or c) baryon.
Definition: ParticleIdUtils.hh:619
bool isBaryon(int pid)
Check to see if this is a valid baryon.
Definition: ParticleIdUtils.hh:260
double charge(int pid)
Return the EM charge (as floating point)
Definition: ParticleIdUtils.hh:868
bool isCharged(int pid)
Determine if the particle is electrically charged.
Definition: ParticleIdUtils.hh:880
bool isHeavyMeson(int pid)
Determine if the PID is that of a heavy flavour (b or c) meson.
Definition: ParticleIdUtils.hh:614
bool isLightMeson(int pid)
Determine if the PID is that of a light flavour (not b or c) meson.
Definition: ParticleIdUtils.hh:629
bool isLightHadron(int pid)
Determine if the PID is that of a light flavour (not b or c) hadron.
Definition: ParticleIdUtils.hh:639
bool hasStrange(int pid)
Does this particle contain a strange quark?
Definition: ParticleIdUtils.hh:577
bool isMuon(int pid)
Determine if the PID is that of an muon or antimuon.
Definition: ParticleIdUtils.hh:148
bool isSUSY(int pid)
Is this a fundamental SUSY particle?
Definition: ParticleIdUtils.hh:362
bool isMagMonopole(int pid)
Is this from a magnetic monopole or dyon?
Definition: ParticleIdUtils.hh:456
bool isFourthGen(int pid)
Is this a 4th generation particle?
Definition: ParticleIdUtils.hh:451
int pid(const Particle &p)
Unbound function access to PID code.
Definition: ParticleUtils.hh:23
int nuclZ(int pid)
Definition: ParticleIdUtils.hh:90
int lSpin(int pid)
lSpin returns 2L+1, where L is the orbital angular momentum
Definition: ParticleIdUtils.hh:764
bool isDarkMatter(int pid)
Definition: ParticleIdUtils.hh:425
bool isExcitedLepton(int pid)
Is this an excited lepton?
Definition: ParticleIdUtils.hh:489
bool isAECO(int pid)
Is this an anomalously electrically charged particle (AECO)?
Definition: ParticleIdUtils.hh:502
bool isCharm(int pid)
Determine if the PID is that of a c/cbar.
Definition: ParticleIdUtils.hh:217
bool isHadron(int pid)
Definition: ParticleIdUtils.hh:322
bool isBottom(int pid)
Determine if the PID is that of a b/bbar.
Definition: ParticleIdUtils.hh:220
bool isPentaquark(int pid)
Check to see if this is a valid pentaquark.
Definition: ParticleIdUtils.hh:300
bool isDM(int pid)
Convenience alias.
Definition: ParticleIdUtils.hh:433
int charge3(int pid)
Three times the EM charge (as integer)
Definition: ParticleIdUtils.hh:800
bool isBottomHadron(int pid)
Determine if the PID is that of a b-hadron.
Definition: ParticleIdUtils.hh:655
bool isTau(int pid)
Determine if the PID is that of an tau or antitau.
Definition: ParticleIdUtils.hh:153
bool isStrangeBaryon(int pid)
Definition: ParticleIdUtils.hh:703
bool isQBall(int pid)
Definition: ParticleIdUtils.hh:473
bool isQball(int pid)
Alias.
Definition: ParticleIdUtils.hh:484
bool isDyon(int pid)
Just treat a dyon as an alias for magmonopole for now.
Definition: ParticleIdUtils.hh:467
bool isGraviton(int pid)
Is this a graviton?
Definition: ParticleIdUtils.hh:202
bool isRHadron(int pid)
Is this an R-hadron?
Definition: ParticleIdUtils.hh:379
bool isLepton(int pid)
Definition: ParticleIdUtils.hh:340
bool isStrangeMeson(int pid)
Definition: ParticleIdUtils.hh:694
bool isTop(int pid)
Determine if the PID is that of a t/tbar.
Definition: ParticleIdUtils.hh:223
double abscharge(int pid)
Return the EM charge (as floating point)
Definition: ParticleIdUtils.hh:871
bool isReggeon(int pid)
Is this a pomeron, odderon, or generic reggeon?
Definition: ParticleIdUtils.hh:232
bool isW(int pid)
Determine if the PID is that of a W+-.
Definition: ParticleIdUtils.hh:184
int abspid(const Particle &p)
Unbound function access to abs PID code.
Definition: ParticleUtils.hh:26
bool hasBottom(int pid)
Does this particle contain a bottom quark?
Definition: ParticleIdUtils.hh:581
bool isTransportable(int pid)
Definition: ParticleIdUtils.hh:935
Location
Definition: ParticleIdUtils.hh:31
std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type in_closed_range(N1 val, N2 low, N3 high)
Boolean function to determine if value is within the given range.
Definition: MathUtils.hh:173
bool hasCharm(int pid)
Does this particle contain a charm quark?
Definition: ParticleIdUtils.hh:579
bool isHeavyParton(int pid)
Determine if the PID is that of a heavy parton (c,b,t)
Definition: ParticleIdUtils.hh:603
bool isQuark(int pid)
Determine if the PID is that of a quark.
Definition: ParticleIdUtils.hh:122
bool isGenSpecific(int pid)
Determine if the PID is in the generator-specific range.
Definition: ParticleIdUtils.hh:920
bool hasTop(int pid)
Does this particle contain a top quark?
Definition: ParticleIdUtils.hh:583
bool isNucleus(int pid)
Is this a nucleus PID?
Definition: ParticleIdUtils.hh:76
int nuclNlambda(int pid)
Definition: ParticleIdUtils.hh:108
bool isCharmMeson(int pid)
Determine if the PID is that of a c-meson.
Definition: ParticleIdUtils.hh:664
bool isRhadron(int pid)
Alias.
Definition: ParticleIdUtils.hh:394
bool isChLepton(int pid)
Definition: ParticleIdUtils.hh:164
bool isHeavyHadron(int pid)
Determine if the PID is that of a heavy flavour (b or c) hadron.
Definition: ParticleIdUtils.hh:624
bool isWplus(int pid)
Determine if the PID is that of a W+.
Definition: ParticleIdUtils.hh:174
bool isExotic(int pid)
Is this an exotic particle?
Definition: ParticleIdUtils.hh:443
int jSpin(int pid)
jSpin returns 2J+1, where J is the total spin
Definition: ParticleIdUtils.hh:725
bool isKK(int pid)
Is this a Kaluza-Klein excitation?
Definition: ParticleIdUtils.hh:409
bool isCharmHadron(int pid)
Definition: ParticleIdUtils.hh:684
bool isStrongInteracting(int pid)
Determine if the PID is that of a strongly interacting particle.
Definition: ParticleIdUtils.hh:896
bool isLightParton(int pid)
Determine if the PID is that of a light parton (u,d,s)
Definition: ParticleIdUtils.hh:608
bool isSMFundamental(int pid)
Is this an SM fundamental particle?
Definition: ParticleIdUtils.hh:353
bool isZ(int pid)
Determine if the PID is that of a Z0.
Definition: ParticleIdUtils.hh:189
bool isResonance(int pid)
Definition: ParticleIdUtils.hh:927
bool isStrangeHadron(int pid)
Definition: ParticleIdUtils.hh:712
bool isMeson(int pid)
Check to see if this is a valid meson.
Definition: ParticleIdUtils.hh:237
bool isHeavyFlavour(int pid)
Determine if the particle is a heavy flavour hadron or parton.
Definition: ParticleIdUtils.hh:592
bool isEMInteracting(int pid)
Determine if the PID is that of a electromagnetically interacting particle.
Definition: ParticleIdUtils.hh:901
bool isNeutrino(int pid)
Determine if the PID is that of a neutrino.
Definition: ParticleIdUtils.hh:167
bool isLeptoQuark(int pid)
Is this a lepto-quark?
Definition: ParticleIdUtils.hh:416
bool isExcited(int pid)
Is this an excited (composite) quark or lepton?
Definition: ParticleIdUtils.hh:403
bool isCharmBaryon(int pid)
Determine if the PID is that of a c-baryon.
Definition: ParticleIdUtils.hh:674
bool isHiddenValley(int pid)
Is this a Hidden Valley particle.
Definition: ParticleIdUtils.hh:438
bool isWeakInteracting(int pid)
Definition: ParticleIdUtils.hh:909
int sSpin(int pid)
sSpin returns 2S+1, where S is the spin
Definition: ParticleIdUtils.hh:741
bool isChargedLepton(int pid)
Determine if the PID is that of a charged lepton.
Definition: ParticleIdUtils.hh:158
bool isBottomMeson(int pid)
Determine if the PID is that of a b-meson.
Definition: ParticleIdUtils.hh:645