PDG_codes.hh

Go to the documentation of this file.

 
#pragma once
 
#include <cstdlib>
#include <string>
 
#include "boost/rational.hpp"
 
namespace HEJ {
 
  namespace pid {
    enum ParticleID: int{
      unspecified = 0,
      d = 1,                           
      down = d,                        
      u = 2,                           
      up = u,                          
      s = 3,                           
      strange = s,                     
      c = 4,                           
      charm = c,                       
      b = 5,                           
      bottom = b,                      
      t = 6,                           
      top = t,                         
      e = 11,                          
      electron = e,                    
      nu_e = 12,                       
      electron_neutrino = nu_e,        
      mu = 13,                         
      muon = mu,                       
      nu_mu = 14,                      
      muon_neutrino = nu_mu,           
      tau = 15,                        
      nu_tau = 16,                     
      tau_neutrino = nu_tau,           
      d_bar = -d,                      
      antidown = d_bar,                
      u_bar = -u,                      
      antiup = -u,                     
      s_bar = -s,                      
      antistrange = -s,                
      c_bar = -c,                      
      anticharm = -c,                  
      b_bar = -b,                      
      antibottom = -b,                 
      t_bar = -t,                      
      antitop = -t,                    
      e_bar = -e,                      
      positron = e_bar,                
      antielectron = positron,         
      nu_e_bar = -nu_e,                
      electron_antineutrino = nu_e_bar,
      mu_bar = -mu,                    
      antimuon = -mu,                  
      nu_mu_bar = -nu_mu,              
      muon_antineutrino = nu_mu_bar,   
      tau_bar = -tau,                  
      antitau = tau_bar,               
      nu_tau_bar = -nu_tau,            
      tau_antineutrino = nu_tau_bar,   
      gluon = 21,                      
      g = gluon,                       
      photon = 22,                     
      gamma = photon,                  
      Z = 23,                          
      Z_photon_mix = 81,               
      Z_gamma_mix = Z_photon_mix,      
      Wp = 24,                         
      Wm = -Wp,                        
      h = 25,                          
      Higgs = h,                       
      higgs = h,                       
      p = 2212,                        
      proton = p,                      
      p_bar = -p,                      
      antiproton = p_bar,              
    };
 
    std::string name(ParticleID id);
 
    ParticleID anti(ParticleID id);
 
  } // namespace pid
 
  using ParticleID = pid::ParticleID;
 
  ParticleID to_ParticleID(std::string const & name);
 
  ParticleID to_ParticleID(std::string_view name);
 
  ParticleID to_ParticleID(char const * name);
 
  inline
  constexpr bool is_antiparticle(ParticleID id) {
    return id < 0;
  }
 
  inline
  constexpr bool is_quark(ParticleID id){
    return (id >= pid::down && id <= pid::top);
  }
 
  inline
  constexpr bool is_antiquark(ParticleID id){
    return (id <= pid::d_bar && id >= pid::t_bar);
  }
 
  inline
  constexpr bool is_anyquark(ParticleID id){
    return is_quark(id) || is_antiquark(id);
  }
 
  inline
  constexpr bool is_gluon(ParticleID id){
    return id == pid::gluon;
  }
  inline
  constexpr bool is_parton(ParticleID id){
    return is_gluon(id)
      || (is_anyquark(id) && std::abs(id) != pid::top);
  }
 
  inline
  constexpr bool is_AWZ_boson(ParticleID id){
    return id == pid::Wm || (id >= pid::photon && id <= pid::Wp)
            || id == pid::Z_photon_mix;
  }
 
  inline
  constexpr bool is_AWZH_boson(ParticleID id){
    return is_AWZ_boson(id) || (id == pid::Higgs);
  }
 
  inline
  constexpr bool is_lepton(ParticleID id){
    return (id >= pid::electron && id <= pid::tau_neutrino);
  }
 
  inline
  constexpr bool is_antilepton(ParticleID id){
    return (id <= pid::positron && id >= pid::nu_tau_bar);
  }
 
  inline
  constexpr bool is_anylepton(ParticleID id){
    return ( is_lepton(id) || is_antilepton(id));
  }
 
  inline
  constexpr bool is_neutrino(ParticleID id){
    return (id == pid::nu_e || id == pid::tau_neutrino
            || id == pid::muon_neutrino);
  }
 
  inline
  constexpr bool is_antineutrino(ParticleID id){
    return (id == pid::nu_e_bar || id == pid::nu_tau_bar
            || id == pid::nu_mu_bar);
  }
 
  inline
  constexpr bool is_anyneutrino(ParticleID id){
    return ( is_neutrino(id) || is_antineutrino(id));
  }
 
  inline
  constexpr bool is_massless(ParticleID id){
    // cannot use `std::abs` because it's not `constexpr`
    const int abs_id = (id >= 0)?id:-id;
    switch(abs_id){
    case pid::bottom:
    case pid::top:
    case pid::tau:
    case pid::Z:
    case pid::Z_photon_mix:
    case pid::Wp:
    case pid::Higgs:
    case pid::proton:
      return false;
    default:
      return true;
    }
  }
 
  inline
  constexpr bool is_massive(ParticleID id){
    return !is_massless(id);
  }
 
  inline
  constexpr bool is_charged_lepton(ParticleID id){
    return is_lepton(id) && !is_neutrino(id);
  }
 
  inline
  constexpr bool is_charged_antilepton(ParticleID id){
    return is_antilepton(id) && !is_antineutrino(id);
  }
 
  inline
  constexpr bool is_charged_anylepton(ParticleID id){
    return is_anylepton(id) && !is_anyneutrino(id);
  }
 
  boost::rational<int> charge(ParticleID id);
 
} // namespace HEJ