Skip to content
Snippets Groups Projects
Commit b49d939a authored by John Derek Chapman's avatar John Derek Chapman Committed by Tadej Novak
Browse files

AtlasPID: Clean-up classification of R-Hadrons and Glueballs 

AtlasPID: Clean-up classification of R-Hadrons and Glueballs
parent 02a8bdd9
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Generators/TruthUtils/TruthUtils/AtlasPID.h
+ 53
− 31
View file @ b49d939a
......@@ -62,6 +62,8 @@ static const int TAU = 15;
static const int NU_TAU = 16;
static const int GLUON = 21;
// APID: 9 rather than 21 is used to denote a gluon/gluino in composite states. (From PDG 11g)
static const int COMPOSITEGLUON = 9;
static const int PHOTON = 22;
static const int Z0BOSON = 23;
static const int WPLUSBOSON = 24;
......@@ -242,16 +244,28 @@ template<> inline bool isGenSpecific(const int& p){
template<> inline bool isGeantino(const int& p){ return (std::abs(p) == GEANTINO0 || std::abs(p) == GEANTINOPLUS);}
/// APID: Definition of Glueballs: SM glueballs 99X (X=1,3,5), 999Y (Y=3,5,7)
template<class T> inline bool isGlueball(const T& p) { return isGlueball(p->pdg_id()); }
template<> inline bool isGlueball(const DecodedPID& p) {
if (p.ndigits() > 4) return false; // APID avoid classifying R-Glueballs as SM Glueballs
size_t ng = 0;
for (size_t i = 1; i + 1 < p.ndigits(); ++i) {
if (p(i) == COMPOSITEGLUON) ng++;
}
return (*(p.second.rbegin()+2)) == COMPOSITEGLUON && (*(p.second.rbegin()+1)) == COMPOSITEGLUON && ng > 0;
}
template<> inline bool isGlueball(const int& p) { auto value_digits = DecodedPID(p); return isGlueball(value_digits); }
/// PDG rule 11d
/// Fundamental supersymmetric particles are identified by adding a nonzeronto the par-ticle number. T
/// he superpartner of a boson or a left-handed fermion hasn= 1whilethe superpartner of a right-handed fermion hasn= 2.
/// When mixing occurs, such asbetween the winos and charged Higgsinos to give charginos, or between left and rightsfermions,
/// the lighter physical state is given the smaller basis state number.
template<> inline bool isSUSY(const DecodedPID& p){return (p.ndigits() == 7 && (p(0) == 1 || p(0) == 2 ) && isValid(p.shift(2)) && !isGenSpecific(p.shift(2).pid()));}
/// 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.
template<> inline bool isSUSY(const DecodedPID& p){return (p.ndigits() == 7 && (p(0) == 1 || p(0) == 2 ) && ((isValid(p.shift(2)) && !isGenSpecific(p.shift(2).pid())) || isGlueball(p.shift(2))) );}
/// PDG rule 11e
/// Technicolor states have n= 3, with technifermions treated like ordinary fermions. States which are ordinary color singlets
/// have nr= 0. Color octets have nr= 1. If a state has non-trivial quantum numbers under the topcolor groups SU(3)1×SU(3)2,
/// 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
template<> inline bool isTechnicolor(const DecodedPID& p){return (p.ndigits() == 7 && p(0) == 3 && (p(1) == 0 || p(0) == 1) && isValid(p.shift(2)) && !isGenSpecific(p.shift(2).pid()));}
......@@ -264,9 +278,9 @@ template<> inline bool isExcited(const int& p){ auto value_digits = DecodedPID(p
/// 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
/// 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 nnr>0, with n= 1 or 2 as usual.
/// 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.
template<> inline bool isKK(const DecodedPID& p){return (p.ndigits() == 7 && (p(0) == 5 || p(0) == 6 ) );}
......@@ -283,7 +297,7 @@ template<> inline bool isMonopole(const int& p){ auto value_digits = DecodedPID(
/// PDG rule 11k
/// Hidden Valley particles have n= 4 and nr= 9, and trailing numbers in agreement with their nearest-analog standard particles,
/// 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 gv of a confining gauge field, 490000 nqv and 490001 nlv fundamental
/// constituents charged or not under this, 4900022 is the γv of a non-confining field, and 4900 nqv1 nqv2 nJ a Hidden Valley meson.
template<> inline bool isHiddenValley(const DecodedPID& p){return (p.ndigits() == 7 && p(0) == 4 && p(1) == 9 && isValid(p.shift(2)));}
......@@ -450,7 +464,7 @@ template<> inline bool isHadron(const int& p){ auto value_digits = DecodedPID(p)
template<> inline bool isTransportable(const DecodedPID& p){ return isPhoton(p.pid()) || isGeantino(p.pid()) || isHadron(p) || isLepton(p.pid()) || p.pid() == DARKPHOTON;}
template<> inline bool isTransportable(const int& p){ auto value_digits = DecodedPID(p); return isTransportable(value_digits);}
/// Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
template<> inline bool isValid(const DecodedPID& p){ return isHadron(p) || isTrajectory(p.pid()) || isDiquark(p) || isBSM(p) || isNucleus(p) || (std::abs(p.pid()) < 42) || isGenSpecific(p.pid()) || isGeantino(p.pid()) || isPythia8Specific(p);}
template<> inline bool isValid(const DecodedPID& p){ return isHadron(p) || isTrajectory(p.pid()) || isDiquark(p) || isBSM(p) || isNucleus(p) || (std::abs(p.pid()) < 42) || isGenSpecific(p.pid()) || isGeantino(p.pid()) || isPythia8Specific(p) || isGlueball(p); }
template<> inline bool isValid(const int& p){ 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);
......@@ -594,43 +608,48 @@ template<> inline double fractionalCharge(const int& p){auto value_digits = Deco
template<class T> inline bool isEMInteracting(const T& p){return isEMInteracting(p->pdg_id());}
template<> inline bool isEMInteracting(const int& p) {return (isPhoton(p) || isZ(p) || std::abs(charge(p))>std::numeric_limits<double>::epsilon() || isMonopole(p));}
template<class T> inline bool isStrongInteracting(const T& p){return isStrongInteracting(p->pdg_id());}
template<> inline bool isStrongInteracting(const int& p) { return (isGluon(p) || isQuark(p) || isDiquark(p) || isLeptoQuark(p) || isHadron(p));}
template<class T> inline bool isParton(const T& p) { return isQuark(p)||isGluon(p);}
namespace SUSY {
static const int SUSYGLUONCODE = 9;
/// 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: NB In the current numbering scheme, there is no way to distinguish between 2 gluinos + gluon and 2 gluons + gluino.
template<class T> inline bool isRGlueball(const T& p) { return isRGlueball(p->pdg_id()); }
template<> inline bool isRGlueball(const DecodedPID& p) {
if (p.ndigits() != 7) return false;
auto pp = p.shift(1).shift(1);
size_t ng = 0;
for (size_t i = 1; i + 1 < pp.ndigits(); ++i) {
if (pp(i) == SUSYGLUONCODE) ng++;
}
return p(1) == 9 && p(2) == 9 && ng > 0;
auto pp = p.shift(2);
return isGlueball(pp);
}
template<> inline bool isRGlueball(const int& p) { auto value_digits = DecodedPID(p); return isRGlueball(value_digits); }
template<class T> inline bool isRHadron(const T& p) { return isRHadron(p->pdg_id()); }
template<> inline bool isRHadron(const DecodedPID& p){ if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false; if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return (isHadron(pp) || isRGlueball(p));}
template<> inline bool isRHadron(const int& p){ auto value_digits = DecodedPID(p); return isRHadron(value_digits);}
template<> inline bool isRHadron(const DecodedPID& p) { if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false; if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return (isHadron(pp) || isRGlueball(p)); }
template<> inline bool isRHadron(const int& p) { auto value_digits = DecodedPID(p); return isRHadron(value_digits); }
template<class T> inline bool isRMeson(const T& p) { return isRMeson(p->pdg_id()); }
template<> inline bool isRMeson(const DecodedPID& p){ if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false;if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return isMeson(pp);}
template<> inline bool isRMeson(const int& p){ auto value_digits = DecodedPID(p); return isRMeson(value_digits);}
template<> inline bool isRMeson(const DecodedPID& p) { if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false;if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return isMeson(pp); }
template<> inline bool isRMeson(const int& p) { auto value_digits = DecodedPID(p); return isRMeson(value_digits); }
template<class T> inline bool isRBaryon(const T& p) { return isRBaryon(p->pdg_id()); }
template<> inline bool isRBaryon(const DecodedPID& p){ if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false; if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return isBaryon(pp);}
template<> inline bool isRBaryon(const int& p){ auto value_digits = DecodedPID(p); return isRBaryon(value_digits);}
template<> inline bool isRBaryon(const DecodedPID& p) { if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false; if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return isBaryon(pp); }
template<> inline bool isRBaryon(const int& p) { auto value_digits = DecodedPID(p); return isRBaryon(value_digits); }
template<class T> inline bool isRBottomHadron(const T& p) { return isRBottomHadron(p->pdg_id()); }
template<> inline bool isRBottomHadron(const DecodedPID& p){ if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false;if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return isBottomHadron(pp);}
template<> inline bool isRBottomHadron(const int& p){ auto value_digits = DecodedPID(p); return isRBottomHadron(value_digits);}
template<> inline bool isRBottomHadron(const DecodedPID& p) { if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false;if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return isBottomHadron(pp); }
template<> inline bool isRBottomHadron(const int& p) { auto value_digits = DecodedPID(p); return isRBottomHadron(value_digits); }
template<class T> inline bool isRTopHadron(const T& p) { return isRTopHadron(p->pdg_id()); }
template<> inline bool isRTopHadron(const DecodedPID& p){ if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false;if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return isTopHadron(pp);}
template<> inline bool isRTopHadron(const int& p){ auto value_digits = DecodedPID(p); return isRTopHadron(value_digits);}
template<> inline bool isRTopHadron(const DecodedPID& p) { if (!isSUSY(p)) return false; auto pp = p.shift(1); if (pp.ndigits() < 2) return false;if ( pp(1) == 7 || pp(1) == 8 ) return false; if (pp.ndigits() > 2) pp = pp.shift(1); return isTopHadron(pp); }
template<> inline bool isRTopHadron(const int& p) { auto value_digits = DecodedPID(p); return isRTopHadron(value_digits); }
template<class T> inline bool isSLepton(const T& p) { return isSLepton(p->pdg_id()); }
......@@ -689,4 +708,7 @@ namespace SUSY {
} // namespace SUSY
template<class T> inline bool isStrongInteracting(const T& p){return isStrongInteracting(p->pdg_id());}
template<> inline bool isStrongInteracting(const int& p) { return (isGluon(p) || isQuark(p) || isDiquark(p) || isGlueball(p) || isLeptoQuark(p) || isHadron(p) || SUSY::isRHadron(p));} // APID: Glueballs and R-Hadrons are also strong-interacting
#endif
Generators/TruthUtils/share/AtlasPIDTest.ref
+ 370
− 369
View file @ b49d939a
This diff is collapsed.
Generators/TruthUtils/test/testPIDs.cxx
+ 15
− 17
View file @ b49d939a
......@@ -55,13 +55,14 @@ int main(int argc, char** argv) {
TEST_FUNCTION(isElectron)
TEST_FUNCTION(isEMInteracting)
TEST_FUNCTION(isGenSpecific)
TEST_FUNCTION(isGlueball)
TEST_FUNCTION(isGluon)
TEST_FUNCTION(isGraviton)
TEST_FUNCTION(isHadron)
TEST_FUNCTION(isHeavyBaryon)
TEST_FUNCTION(isHeavyHadron)
TEST_FUNCTION(isHeavyMeson)
TEST_FUNCTION(isHiggs) // 30
TEST_FUNCTION(isHeavyMeson) // 30
TEST_FUNCTION(isHiggs)
TEST_FUNCTION(isLepton)
TEST_FUNCTION(isLeptoQuark)
TEST_FUNCTION(isLightBaryon)
......@@ -70,8 +71,8 @@ int main(int argc, char** argv) {
TEST_FUNCTION(isMeson)
TEST_FUNCTION(isMuon)
TEST_FUNCTION(isNeutral)
TEST_FUNCTION(isNeutrino)
TEST_FUNCTION(isNucleus) // 40
TEST_FUNCTION(isNeutrino) // 40
TEST_FUNCTION(isNucleus)
TEST_FUNCTION(isParton)
TEST_FUNCTION(isPentaquark)
TEST_FUNCTION(isPhoton)
......@@ -80,22 +81,19 @@ int main(int argc, char** argv) {
TEST_FUNCTION(isStrange)
TEST_FUNCTION(isStrangeBaryon)
TEST_FUNCTION(isStrangeHadron)
TEST_FUNCTION(isStrangeMeson)
TEST_FUNCTION(isStrongInteracting) // 50
TEST_FUNCTION(isStrangeMeson) // 50
TEST_FUNCTION(isStrongInteracting)
TEST_FUNCTION(isSUSY)
TEST_FUNCTION(isTau)
/*TEST_FUNCTION(isTetraquark) */
TEST_FUNCTION(isTop)
/*TEST_FUNCTION(isTrajectory)*/
TEST_FUNCTION(isTransportable)
TEST_FUNCTION(isValid)
TEST_FUNCTION(isW)
TEST_FUNCTION(isZ)
/*TEST_FUNCTION(leadingQuark)*/
TEST_FUNCTION(threeCharge)
/* NEW **/
TEST_FUNCTION(isBBbarMeson)
TEST_FUNCTION(isCCbarMeson) // 60
TEST_FUNCTION(isBBbarMeson) // 60
TEST_FUNCTION(isCCbarMeson)
TEST_FUNCTION(isExcited)
TEST_FUNCTION(isGeantino)
TEST_FUNCTION(isHiddenValley)
......@@ -104,8 +102,8 @@ int main(int argc, char** argv) {
TEST_FUNCTION(isPythia8Specific)
TEST_FUNCTION(SUSY::isRBaryon)
TEST_FUNCTION(SUSY::isRBottomHadron)
TEST_FUNCTION(SUSY::isRGlueball)
TEST_FUNCTION(SUSY::isRHadron) // 70
TEST_FUNCTION(SUSY::isRGlueball) // 70
TEST_FUNCTION(SUSY::isRHadron)
TEST_FUNCTION(SUSY::isRMeson)
TEST_FUNCTION(SUSY::isRTopHadron)
TEST_FUNCTION(SUSY::isSBaryon)
......@@ -114,8 +112,8 @@ int main(int argc, char** argv) {
TEST_FUNCTION(SUSY::isSBottomMeson)
TEST_FUNCTION(SUSY::isSLepton)
TEST_FUNCTION(isSMLepton)
TEST_FUNCTION(isSMNeutrino)
TEST_FUNCTION(SUSY::isSMeson) // 80
TEST_FUNCTION(isSMNeutrino) // 80
TEST_FUNCTION(SUSY::isSMeson)
TEST_FUNCTION(SUSY::isSTopBaryon)
TEST_FUNCTION(SUSY::isSTopHadron)
TEST_FUNCTION(SUSY::isSTopMeson)
......@@ -123,8 +121,8 @@ int main(int argc, char** argv) {
TEST_FUNCTION(isTopBaryon)
TEST_FUNCTION(isTopHadron)
TEST_FUNCTION(isTopMeson)
TEST_FUNCTION(isTrajectory)
TEST_FUNCTION(leadingQuark) // 90
TEST_FUNCTION(isTrajectory) // 90
TEST_FUNCTION(leadingQuark)
TEST_FUNCTION(SUSY::spin)
if (myline!=current) { printf("reference :%s\ncalculated:%s\n",myline.c_str(),current.c_str()); return 1; }
//printf("%s\n",current.c_str());
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment