Utilities for improving the code readability when using PDG codes. More...

Functions
bool	IsPseudoParticle (int pdgc)

bool	IsIon (int pdgc)

bool	IsParticle (int pdgc)
	not ion or pseudo-particle More...

int	IonPdgCodeToZ (int pdgc)

int	IonPdgCodeToA (int pdgc)

int	IonPdgCode (int A, int Z)

int	IonPdgCode (int A, int Z, int L, int I)

bool	IsLepton (int pdgc)

bool	IsNeutralLepton (int pdgc)

bool	IsChargedLepton (int pdgc)

bool	IsNeutrino (int pdgc)

bool	IsAntiNeutrino (int pdgc)

bool	IsNegChargedLepton (int pdgc)

bool	IsPosChargedLepton (int pdgc)

bool	IsDarkMatter (int pdgc)

bool	IsAntiDarkMatter (int pdgc)

bool	IsNuE (int pdgc)

bool	IsNuMu (int pdgc)

bool	IsNuTau (int pdgc)

bool	IsAntiNuE (int pdgc)

bool	IsAntiNuMu (int pdgc)

bool	IsAntiNuTau (int pdgc)

bool	IsElectron (int pdgc)

bool	IsPositron (int pdgc)

bool	IsMuon (int pdgc)

bool	IsAntiMuon (int pdgc)

bool	IsTau (int pdgc)

bool	IsAntiTau (int pdgc)

bool	IsDiQuark (int pdgc)

bool	IsQuark (int pdgc)

bool	IsUQuark (int pdgc)

bool	IsDQuark (int pdgc)

bool	IsSQuark (int pdgc)

bool	IsCQuark (int pdgc)

bool	IsBQuark (int pdgc)

bool	IsTQuark (int pdgc)

bool	IsAntiQuark (int pdgc)

bool	IsAntiUQuark (int pdgc)

bool	IsAntiDQuark (int pdgc)

bool	IsAntiSQuark (int pdgc)

bool	IsAntiCQuark (int pdgc)

bool	IsAntiBQuark (int pdgc)

bool	IsAntiTQuark (int pdgc)

bool	IsKaon (int pdgc)

bool	IsPion (int pdgc)

bool	IsProton (int pdgc)

bool	IsNeutron (int pdgc)

bool	IsNucleon (int pdgc)

bool	IsNeutronOrProton (int pdgc)

bool	IsHadron (int pdgc)

bool	IsBaryonResonance (int pdgc)

bool	Is2NucleonCluster (int pdgc)

bool	IsDarkSectorParticle (int pdgc)

int	SwitchProtonNeutron (int pdgc)

int	ModifyNucleonCluster (int pdgc, int dQ)

int	Neutrino2ChargedLepton (int pdgc)

int	GeantToPdg (int geant_code)

Detailed Description

Utilities for improving the code readability when using PDG codes.

Author: Costas Andreopoulos <constantinos.andreopoulos cern.ch> University of Liverpool & STFC Rutherford Appleton Laboratory

Changes required to implement the GENIE Boosted Dark Matter module were installed by Josh Berger (Univ. of Wisconsin)

May 06, 2004

Function Documentation

int genie::pdg::GeantToPdg ( int geant_code )

Definition at line 416 of file PDGUtils.cxx.

 {
   if(geant_code ==  3) return kPdgElectron;     //    11 / e-
   if(geant_code ==  2) return kPdgPositron;     //   -11 / e+
   if(geant_code ==  6) return kPdgMuon;         //    13 / mu-
   if(geant_code ==  5) return kPdgAntiMuon;     //   -13 / mu+
   if(geant_code == 34) return kPdgTau;          //    15 / tau-
   if(geant_code == 33) return kPdgAntiTau;      //   -15 / tau+
   if(geant_code ==  8) return kPdgPiP;          //   211 / pi+
   if(geant_code ==  9) return kPdgPiM;          //  -211 / pi-
   if(geant_code ==  7) return kPdgPi0;          //   111 / pi0
   if(geant_code == 17) return kPdgEta;          //   221 / eta
   if(geant_code == 11) return kPdgKP;           //   321 / K+
   if(geant_code == 12) return kPdgKM;           //  -321 / K-
   if(geant_code == 10) return kPdgK0L;          //   130 / K0_{long}
   if(geant_code == 16) return kPdgK0S;          //   310 / K0_{short}
   if(geant_code == 35) return kPdgDP;           //   411 / D+
   if(geant_code == 36) return kPdgDM;           //  -411 / D-
   if(geant_code == 37) return kPdgD0;           //   421 / D0
   if(geant_code == 38) return kPdgAntiD0;       //  -421 / \bar{D0}
   if(geant_code == 39) return kPdgDPs;          //   431 / D+_{s}
   if(geant_code == 40) return kPdgDMs;          //  -431 / D-_{s}
   if(geant_code ==  1) return kPdgGamma;        //    22 / photon
   if(geant_code == 44) return kPdgZ0;           //    23 / Z
   if(geant_code == 42) return kPdgWP;           //    24 / W+
   if(geant_code == 43) return kPdgWM;           //   -24 / W-
   if(geant_code == 14) return kPdgProton;       //  2212
   if(geant_code == 15) return kPdgAntiProton;   // -2212
   if(geant_code == 13) return kPdgNeutron;      //  2112
   if(geant_code == 25) return kPdgAntiNeutron;  // -2112
   if(geant_code == 18) return kPdgLambda;       //  3122 / Lambda
   if(geant_code == 26) return kPdgAntiLambda;   // -3122 / \bar{Lambda}
   if(geant_code == 19) return kPdgSigmaP;       //  3222 / Sigma+
   if(geant_code == 20) return kPdgSigma0;       //  3212 / Sigma0
   if(geant_code == 21) return kPdgSigmaM;       //  3112 / Sigma-
   if(geant_code == 29) return kPdgAntiSigmaP;   // -3112 / \bar{Sigma+}
   if(geant_code == 28) return kPdgAntiSigma0;   // -3212 / \bar{Sigma0}
   if(geant_code == 27) return kPdgAntiSigmaM;   // -3112 / \bar{Sigma-}
   if(geant_code == 22) return kPdgXi0;          //  3322 / Xi0
   if(geant_code == 23) return kPdgXiM;          //  3312 / Xi-
   if(geant_code == 30) return kPdgAntiXi0;      // -3322 / \bar{Xi0}
   if(geant_code == 31) return kPdgAntiXiP;      // -3312 / \bar{Xi+}
   if(geant_code == 24) return kPdgOmegaM;       //  3334 / Omega-
   if(geant_code == 32) return kPdgAntiOmegaP;   // -3334 / \bar{Omega+}
 
   // some rare Geant3 codes that don't really need definitions in PDGCodes.h
   const int kPdgDeuteron = 1000010020; // pdg::IonPdgCode(2,1);
   const int kPdgTritium  = 1000010030; // pdg::IonPdgCode(3,1);
   const int kPdgAlpha    = 1000020040; // pdg::IonPdgCode(4,2);
   const int kPdgHe3      = 1000020030; // pdg::IonPdgCode(3,2);
   if(geant_code == 45) return kPdgDeuteron;
   if(geant_code == 46) return kPdgTritium;
   if(geant_code == 47) return kPdgAlpha;
   if(geant_code == 49) return kPdgHe3;
 
   LOG("PDG", pWARN)
         << "Can not convert geant code: " << geant_code << " to PDG";
   return 0;
 }

int genie::pdg::IonPdgCode	(	int	A,
		int	Z
	)

Definition at line 68 of file PDGUtils.cxx.

 {
 // Build ion PDG code from A,Z
 
   return IonPdgCode(A,Z,0,0);
 }

int genie::pdg::IonPdgCode	(	int	A,
		int	Z,
		int	L,
		int	I
	)

Definition at line 75 of file PDGUtils.cxx.

 {
 // Build ion PDG code from A,Z,L,I
 
   int ion_pdgc = 1000000000 +  L*100000000 + Z*10000 + A*10 + I;
   return ion_pdgc;
 }

int genie::pdg::IonPdgCodeToA ( int pdgc )

Definition at line 60 of file PDGUtils.cxx.

 {
 // Decoding A from the PDG code (PDG ion code convention: 10LZZZAAAI)
 
   int A = (ion_pdgc/10) - 1000*(ion_pdgc/10000); // don't factor out!
   return A;
 }

int genie::pdg::IonPdgCodeToZ ( int pdgc )

Definition at line 52 of file PDGUtils.cxx.

 {
 // Decoding Z from the PDG code (PDG ion code convention: 10LZZZAAAI)
 
   int Z = (ion_pdgc/10000) - 1000*(ion_pdgc/10000000); // don't factor out!
   return Z;
 }

bool genie::pdg::Is2NucleonCluster ( int pdgc )

Definition at line 399 of file PDGUtils.cxx.

 {
    return (
       pdgc == kPdgClusterNN   ||
       pdgc == kPdgClusterNP   ||
       pdgc == kPdgClusterPP
    );
 }

bool genie::pdg::IsAntiBQuark ( int pdgc )

Definition at line 313 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiBQuark);
 }

bool genie::pdg::IsAntiCQuark ( int pdgc )

Definition at line 308 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiCQuark);
 }

bool genie::pdg::IsAntiDarkMatter ( int pdgc )

Definition at line 130 of file PDGUtils.cxx.

 {
   bool is_dmbar = (pdgc == kPdgAntiDarkMatter);
   return is_dmbar;
 }

bool genie::pdg::IsAntiDQuark ( int pdgc )

Definition at line 298 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiDQuark);
 }

bool genie::pdg::IsAntiMuon ( int pdgc )

Definition at line 200 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiMuon);
 }

bool genie::pdg::IsAntiNeutrino ( int pdgc )

Definition at line 115 of file PDGUtils.cxx.

 {
   bool is_nubar = (pdgc == kPdgAntiNuE)  ||
                   (pdgc == kPdgAntiNuMu) ||
                   (pdgc == kPdgAntiNuTau);
 
   return is_nubar;
 }

bool genie::pdg::IsAntiNuE ( int pdgc )

Definition at line 170 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiNuE);
 }

bool genie::pdg::IsAntiNuMu ( int pdgc )

Definition at line 175 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiNuMu);
 }

bool genie::pdg::IsAntiNuTau ( int pdgc )

Definition at line 180 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiNuTau);
 }

bool genie::pdg::IsAntiQuark ( int pdgc )

Definition at line 255 of file PDGUtils.cxx.

 {
   return ( pdgc == kPdgAntiDQuark || pdgc == kPdgAntiUQuark ||
            pdgc == kPdgAntiSQuark || pdgc == kPdgAntiCQuark ||
            pdgc == kPdgAntiBQuark || pdgc == kPdgAntiTQuark
          );
 }

bool genie::pdg::IsAntiSQuark ( int pdgc )

Definition at line 303 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiSQuark);
 }

bool genie::pdg::IsAntiTau ( int pdgc )

Definition at line 210 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiTau);
 }

bool genie::pdg::IsAntiTQuark ( int pdgc )

Definition at line 318 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiTQuark);
 }

bool genie::pdg::IsAntiUQuark ( int pdgc )

Definition at line 293 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgAntiUQuark);
 }

bool genie::pdg::IsBaryonResonance ( int pdgc )

Definition at line 394 of file PDGUtils.cxx.

 {
   return utils::res::IsBaryonResonance(pdgc);
 }

bool genie::pdg::IsBQuark ( int pdgc )

Definition at line 283 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgBQuark);
 }

bool genie::pdg::IsChargedLepton ( int pdgc )

Definition at line 98 of file PDGUtils.cxx.

 {
   bool is_neg_lepton = genie::pdg::IsNegChargedLepton(pdgc);
   bool is_pos_lepton = genie::pdg::IsPosChargedLepton(pdgc);
 
   bool is_charged_lepton = is_neg_lepton || is_pos_lepton;
   return is_charged_lepton;
 }

bool genie::pdg::IsCQuark ( int pdgc )

Definition at line 278 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgCQuark);
 }

bool genie::pdg::IsDarkMatter ( int pdgc )

Definition at line 124 of file PDGUtils.cxx.

 {
   bool is_dm = (pdgc == kPdgDarkMatter);
   return is_dm;
 }

bool genie::pdg::IsDarkSectorParticle ( int pdgc )

Definition at line 408 of file PDGUtils.cxx.

 {
   return (
     pdgc == kPdgDarkNeutrino ||
     pdgc == kPdgDNuMediator
     );
 }

bool genie::pdg::IsDiQuark ( int pdgc )

Definition at line 228 of file PDGUtils.cxx.

 {
   return ( pdgc == kPdgDDDiquarkS1 || pdgc == kPdgUDDiquarkS0 ||
            pdgc == kPdgUDDiquarkS1 || pdgc == kPdgUUDiquarkS1 ||
            pdgc == kPdgSDDiquarkS0 || pdgc == kPdgSDDiquarkS1 ||
            pdgc == kPdgSUDiquarkS0 || pdgc == kPdgSUDiquarkS1 ||
            pdgc == kPdgSSDiquarkS1 || 
            pdgc == kPdgCDDiquarkS0 || pdgc == kPdgCDDiquarkS1 || 
            pdgc == kPdgCUDiquarkS0 || pdgc == kPdgCUDiquarkS1 || 
            pdgc == kPdgCSDiquarkS0 || pdgc == kPdgCSDiquarkS1 || 
            pdgc == kPdgCCDiquarkS1 || 
            pdgc == kPdgBDDiquarkS0 || pdgc == kPdgBDDiquarkS1 || 
            pdgc == kPdgBUDiquarkS0 || pdgc == kPdgBUDiquarkS1 || 
            pdgc == kPdgBSDiquarkS0 || pdgc == kPdgBSDiquarkS1 || 
            pdgc == kPdgBCDiquarkS0 || pdgc == kPdgBCDiquarkS1 || 
            pdgc == kPdgBBDiquarkS1
          );
 }

bool genie::pdg::IsDQuark ( int pdgc )

Definition at line 268 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgDQuark);
 }

bool genie::pdg::IsElectron ( int pdgc )

Definition at line 185 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgElectron);
 }

bool genie::pdg::IsHadron ( int pdgc )

Definition at line 389 of file PDGUtils.cxx.

 {
   return ((pdgc>=100 && pdgc<=9999) || (pdgc>=-9999 && pdgc<=-100));
 }

bool genie::pdg::IsIon ( int pdgc )

Definition at line 39 of file PDGUtils.cxx.

 {
   return (pdgc > 1000000000 && pdgc < 1999999999);
 }

bool genie::pdg::IsKaon ( int pdgc )

Definition at line 328 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgKP || pdgc == kPdgK0 || pdgc == kPdgKM);
 }

bool genie::pdg::IsLepton ( int pdgc )

Definition at line 83 of file PDGUtils.cxx.

 {
   bool is_neutral_lepton = genie::pdg::IsNeutralLepton(pdgc);
   bool is_charged_lepton = genie::pdg::IsChargedLepton(pdgc);
 
   bool is_lepton = (is_neutral_lepton || is_charged_lepton);
   return is_lepton;
 }

bool genie::pdg::IsMuon ( int pdgc )

Definition at line 195 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgMuon);
 }

bool genie::pdg::IsNegChargedLepton ( int pdgc )

Definition at line 136 of file PDGUtils.cxx.

 {
   bool is_neg_lepton = (pdgc ==  kPdgElectron) ||
                        (pdgc ==  kPdgMuon)     ||
                        (pdgc ==  kPdgTau);
 
   return is_neg_lepton;
 }

bool genie::pdg::IsNeutralLepton ( int pdgc )

Definition at line 92 of file PDGUtils.cxx.

 {
   bool is_neutral_lepton = IsNeutrino(pdgc) || IsAntiNeutrino(pdgc);
   return is_neutral_lepton;
 }

bool genie::pdg::IsNeutrino ( int pdgc )

Definition at line 107 of file PDGUtils.cxx.

 {
   bool is_nu = (pdgc == kPdgNuE)  ||
                (pdgc == kPdgNuMu) ||
                (pdgc == kPdgNuTau);
   return is_nu;
 }

bool genie::pdg::IsNeutron ( int pdgc )

Definition at line 338 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgNeutron);
 }

bool genie::pdg::IsNeutronOrProton ( int pdgc )

Definition at line 348 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgNeutron || pdgc == kPdgProton);
 }

bool genie::pdg::IsNucleon ( int pdgc )

Definition at line 343 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgNeutron || pdgc == kPdgProton);
 }

bool genie::pdg::IsNuE ( int pdgc )

Definition at line 155 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgNuE);
 }

bool genie::pdg::IsNuMu ( int pdgc )

Definition at line 160 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgNuMu);
 }

bool genie::pdg::IsNuTau ( int pdgc )

Definition at line 165 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgNuTau);
 }

bool genie::pdg::IsParticle ( int pdgc )

not ion or pseudo-particle

Definition at line 44 of file PDGUtils.cxx.

 {
   if( genie::pdg::IsPseudoParticle (pdgc) ) return false;
   if( genie::pdg::IsIon            (pdgc) ) return false;
 
   return true;
 }

bool genie::pdg::IsPion ( int pdgc )

Definition at line 323 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgPiP || pdgc == kPdgPi0 || pdgc == kPdgPiM);
 }

bool genie::pdg::IsPosChargedLepton ( int pdgc )

Definition at line 145 of file PDGUtils.cxx.

 {
   bool is_pos_lepton = (pdgc ==  kPdgPositron) ||
                        (pdgc ==  kPdgAntiMuon) ||
                        (pdgc ==  kPdgAntiTau);
 
   return is_pos_lepton;
 }

bool genie::pdg::IsPositron ( int pdgc )

Definition at line 190 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgPositron);
 }

bool genie::pdg::IsProton ( int pdgc )

Definition at line 333 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgProton);
 }

bool genie::pdg::IsPseudoParticle ( int pdgc )

Definition at line 24 of file PDGUtils.cxx.

 {
 // ROOT's rootino has PDG code=0
 // GENIE pseudoparticles are in the 2000000000-2000100000 range
 // Include PYTHIA's pseudoparticles
 
   bool is_fake =
      ( (pdgc == 0) ||
        (pdgc > 2000000000 && pdgc < 2000100000) ||
        (pdgc == kPdgCluster || pdgc == kPdgString || pdgc == kPdgIndep)
      );
 
   return is_fake;
 }

bool genie::pdg::IsQuark ( int pdgc )

Definition at line 247 of file PDGUtils.cxx.

 {
   return ( pdgc == kPdgDQuark || pdgc == kPdgUQuark ||
            pdgc == kPdgSQuark || pdgc == kPdgCQuark ||
            pdgc == kPdgBQuark || pdgc == kPdgTQuark
          );
 }

bool genie::pdg::IsSQuark ( int pdgc )

Definition at line 273 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgSQuark);
 }

bool genie::pdg::IsTau ( int pdgc )

Definition at line 205 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgTau);
 }

bool genie::pdg::IsTQuark ( int pdgc )

Definition at line 288 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgTQuark);
 }

bool genie::pdg::IsUQuark ( int pdgc )

Definition at line 263 of file PDGUtils.cxx.

 {
   return (pdgc == kPdgUQuark);
 }

int genie::pdg::ModifyNucleonCluster	(	int	pdgc,
		int	dQ
	)

Definition at line 361 of file PDGUtils.cxx.

 {
   assert(pdg::Is2NucleonCluster(pdgc));
 
   if(pdgc == kPdgClusterNN) {
     if      (dQ ==  0) { return kPdgClusterNN; }
     else if (dQ == +1) { return kPdgClusterNP; }
     else if (dQ == +2) { return kPdgClusterPP; }
     else               { return 0;             }
   }
   else
   if(pdgc == kPdgClusterNP) {
     if      (dQ == -1) { return kPdgClusterNN; }
     else if (dQ ==  0) { return kPdgClusterNP; }
     else if (dQ == +1) { return kPdgClusterPP; }
     else               { return 0;             }
   }
   else
   if(pdgc == kPdgClusterPP) {
     if      (dQ == -2) { return kPdgClusterNN; }
     else if (dQ == -1) { return kPdgClusterNP; }
     else if (dQ ==  0) { return kPdgClusterPP; }
     else               { return 0;             }
   }
 
   return 0;
 }

int genie::pdg::Neutrino2ChargedLepton ( int pdgc )

Definition at line 215 of file PDGUtils.cxx.

 {
   switch(pdgc) {
        case (kPdgNuE)      : return kPdgElectron; break;
        case (kPdgAntiNuE)  : return kPdgPositron; break;
        case (kPdgNuMu)     : return kPdgMuon;     break;
        case (kPdgAntiNuMu) : return kPdgAntiMuon; break;
        case (kPdgNuTau)    : return kPdgTau;      break;
        case (kPdgAntiNuTau): return kPdgAntiTau;  break;
   }
   return -1;
 }

int genie::pdg::SwitchProtonNeutron ( int pdgc )

Definition at line 353 of file PDGUtils.cxx.

 {
   assert(IsProton(pdgc) || IsNeutron(pdgc));
 
   if (IsProton(pdgc)) return kPdgNeutron;
   else                return kPdgProton;
 }

Functions

Detailed Description

Function Documentation