PDGUtils.cxx

Go to the documentation of this file.

//____________________________________________________________________________
/*
 Copyright (c) 2003-2024, The GENIE Collaboration
 For the full text of the license visit http://copyright.genie-mc.org

 Costas Andreopoulos <c.andreopoulos \at cern.ch>
 University of Liverpool

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

         Changes required to implement the GENIE BeamHNL module
         were installed by John Plows (Univ. of Oxford)
*/
//____________________________________________________________________________

#include <cassert>

#include "Framework/ParticleData/BaryonResUtils.h"
#include "Framework/Messenger/Messenger.h"
#include "Framework/ParticleData/PDGUtils.h"
#include "Framework/ParticleData/PDGCodes.h"

using namespace genie;

//____________________________________________________________________________
bool genie::pdg::IsPseudoParticle(int pdgc)
{
// 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::IsIon(int pdgc)
{
  return (pdgc > 1000000000 && pdgc < 1999999999);
}
//____________________________________________________________________________
bool genie::pdg::IsParticle(int pdgc)
{
  if( genie::pdg::IsPseudoParticle (pdgc) ) return false;
  if( genie::pdg::IsIon            (pdgc) ) return false;

  return true;
}
//____________________________________________________________________________
int genie::pdg::IonPdgCodeToZ(int ion_pdgc)
{
// 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;
}
//____________________________________________________________________________
int genie::pdg::IonPdgCodeToA(int ion_pdgc)
{
// 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::IonPdgCode(int A, int Z)
{
// 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)
{
// Build ion PDG code from A,Z,L,I

  int ion_pdgc = 1000000000 +  L*100000000 + Z*10000 + A*10 + I;
  return ion_pdgc;
}
//____________________________________________________________________________
bool genie::pdg::IsLepton(int pdgc)
{
  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::IsNeutralLepton(int pdgc)
{
  bool is_neutral_lepton = IsNeutrino(pdgc) || IsAntiNeutrino(pdgc);
  return is_neutral_lepton;
}
//____________________________________________________________________________
bool genie::pdg::IsChargedLepton(int pdgc)
{
  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::IsNeutrino(int pdgc)
{
  bool is_nu = (pdgc == kPdgNuE)  ||
               (pdgc == kPdgNuMu) ||
               (pdgc == kPdgNuTau);
  return is_nu;
}
//____________________________________________________________________________
bool genie::pdg::IsAntiNeutrino(int pdgc)
{
  bool is_nubar = (pdgc == kPdgAntiNuE)  ||
                  (pdgc == kPdgAntiNuMu) ||
                  (pdgc == kPdgAntiNuTau);

  return is_nubar;
}
//____________________________________________________________________________
bool genie::pdg::IsDarkMatter(int pdgc)
{
  bool is_dm = (pdgc == kPdgDarkMatter);
  return is_dm;
}
//____________________________________________________________________________
bool genie::pdg::IsAntiDarkMatter(int pdgc)
{
  bool is_dmbar = (pdgc == kPdgAntiDarkMatter);
  return is_dmbar;
}
//____________________________________________________________________________
bool genie::pdg::IsNegChargedLepton(int pdgc)
{
  bool is_neg_lepton = (pdgc ==  kPdgElectron) ||
                       (pdgc ==  kPdgMuon)     ||
                       (pdgc ==  kPdgTau);

  return is_neg_lepton;
}
//____________________________________________________________________________
bool genie::pdg::IsPosChargedLepton(int pdgc)
{
  bool is_pos_lepton = (pdgc ==  kPdgPositron) ||
                       (pdgc ==  kPdgAntiMuon) ||
                       (pdgc ==  kPdgAntiTau);

  return is_pos_lepton;
}
//____________________________________________________________________________

bool genie::pdg::IsNuE(int pdgc)
{
  return (pdgc == kPdgNuE);
}
//____________________________________________________________________________
bool genie::pdg::IsNuMu(int pdgc)
{
  return (pdgc == kPdgNuMu);
}
//____________________________________________________________________________
bool genie::pdg::IsNuTau(int pdgc)
{
  return (pdgc == kPdgNuTau);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiNuE(int pdgc)
{
  return (pdgc == kPdgAntiNuE);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiNuMu(int pdgc)
{
  return (pdgc == kPdgAntiNuMu);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiNuTau(int pdgc)
{
  return (pdgc == kPdgAntiNuTau);
}
//____________________________________________________________________________
bool genie::pdg::IsElectron(int pdgc)
{
  return (pdgc == kPdgElectron);
}
//____________________________________________________________________________
bool genie::pdg::IsPositron(int pdgc)
{
  return (pdgc == kPdgPositron);
}
//____________________________________________________________________________
bool genie::pdg::IsMuon(int pdgc)
{
  return (pdgc == kPdgMuon);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiMuon(int pdgc)
{
  return (pdgc == kPdgAntiMuon);
}
//____________________________________________________________________________
bool genie::pdg::IsTau(int pdgc)
{
  return (pdgc == kPdgTau);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiTau(int pdgc)
{
  return (pdgc == kPdgAntiTau);
}
//____________________________________________________________________________
int genie::pdg::Neutrino2ChargedLepton(int pdgc)
{
  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;
}
//____________________________________________________________________________
bool genie::pdg::IsDiQuark(int pdgc)
{
  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::IsQuark(int pdgc)
{
  return ( pdgc == kPdgDQuark || pdgc == kPdgUQuark ||
           pdgc == kPdgSQuark || pdgc == kPdgCQuark ||
           pdgc == kPdgBQuark || pdgc == kPdgTQuark
         );
}
//____________________________________________________________________________
bool genie::pdg::IsAntiQuark(int pdgc)
{
  return ( pdgc == kPdgAntiDQuark || pdgc == kPdgAntiUQuark ||
           pdgc == kPdgAntiSQuark || pdgc == kPdgAntiCQuark ||
           pdgc == kPdgAntiBQuark || pdgc == kPdgAntiTQuark
         );
}
//____________________________________________________________________________
bool genie::pdg::IsUQuark(int pdgc)
{
  return (pdgc == kPdgUQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsDQuark(int pdgc)
{
  return (pdgc == kPdgDQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsSQuark(int pdgc)
{
  return (pdgc == kPdgSQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsCQuark(int pdgc)
{
  return (pdgc == kPdgCQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsBQuark(int pdgc)
{
  return (pdgc == kPdgBQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsTQuark(int pdgc)
{
  return (pdgc == kPdgTQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiUQuark(int pdgc)
{
  return (pdgc == kPdgAntiUQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiDQuark(int pdgc)
{
  return (pdgc == kPdgAntiDQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiSQuark(int pdgc)
{
  return (pdgc == kPdgAntiSQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiCQuark(int pdgc)
{
  return (pdgc == kPdgAntiCQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiBQuark(int pdgc)
{
  return (pdgc == kPdgAntiBQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsAntiTQuark(int pdgc)
{
  return (pdgc == kPdgAntiTQuark);
}
//____________________________________________________________________________
bool genie::pdg::IsPion(int pdgc)
{
  return (pdgc == kPdgPiP || pdgc == kPdgPi0 || pdgc == kPdgPiM);
}
//____________________________________________________________________________
bool genie::pdg::IsKaon(int pdgc)
{
  return (pdgc == kPdgKP || pdgc == kPdgK0 || pdgc == kPdgKM);
}
//____________________________________________________________________________
bool genie::pdg::IsProton(int pdgc)
{
  return (pdgc == kPdgProton);
}
//____________________________________________________________________________
bool genie::pdg::IsNeutron(int pdgc)
{
  return (pdgc == kPdgNeutron);
}
//____________________________________________________________________________
bool genie::pdg::IsNucleon(int pdgc)
{
  return (pdgc == kPdgNeutron || pdgc == kPdgProton);
}
//____________________________________________________________________________
bool genie::pdg::IsNeutronOrProton(int pdgc)
{
  return (pdgc == kPdgNeutron || pdgc == kPdgProton);
}
//____________________________________________________________________________
int genie::pdg::SwitchProtonNeutron(int pdgc)
{
  assert(IsProton(pdgc) || IsNeutron(pdgc));

  if (IsProton(pdgc)) return kPdgNeutron;
  else                return kPdgProton;
}
//____________________________________________________________________________
int genie::pdg::ModifyNucleonCluster(int pdgc, int dQ)
{
  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;
}
//____________________________________________________________________________
bool genie::pdg::IsHadron(int pdgc)
{
  return ((pdgc>=100 && pdgc<=9999) || (pdgc>=-9999 && pdgc<=-100));
}
//____________________________________________________________________________
bool genie::pdg::IsBaryonResonance(int pdgc)
{
  return utils::res::IsBaryonResonance(pdgc);
}
//____________________________________________________________________________
bool genie::pdg::Is2NucleonCluster(int pdgc)
{
   return (
      pdgc == kPdgClusterNN   ||
      pdgc == kPdgClusterNP   ||
      pdgc == kPdgClusterPP
   );
}
//____________________________________________________________________________
bool genie::pdg::IsDarkSectorParticle(int pdgc)
{
  return (
    pdgc == kPdgDarkNeutrino ||
    pdgc == kPdgDNuMediator
    );
}
//____________________________________________________________________________
bool genie::pdg::IsHNL(int pdgc)
{
  return ( std::abs( pdgc ) == kPdgHNL );
}
//____________________________________________________________________________
int genie::pdg::GeantToPdg(int geant_code)
{
  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;
}
//____________________________________________________________________________