README

heppdt

GoDoc

heppdt provides access to the HEP Particle Data Table.

It has been heavily inspired from the C++ HepPDT library.

Installation

$ go get go-hep.org/x/hep/heppdt

Documentation

Documentation is available on https://godoc.org/go-hep.org/x/hep/heppdt

References

Expand ▾ Collapse ▴

Documentation

Overview

    Package heppdt provides access to the HEP Particle Data Table.

    Index

    Constants

    View Source
    const (
    	PDG_d                             = 1
    	PDG_anti_d                        = -1
    	PDG_u                             = 2
    	PDG_anti_u                        = -2
    	PDG_s                             = 3
    	PDG_anti_s                        = -3
    	PDG_c                             = 4
    	PDG_anti_c                        = -4
    	PDG_b                             = 5
    	PDG_anti_b                        = -5
    	PDG_t                             = 6
    	PDG_anti_t                        = -6
    	PDG_l                             = 7
    	PDG_anti_l                        = -7
    	PDG_h                             = 8
    	PDG_anti_h                        = -8
    	PDG_g                             = 21
    	PDG_e_minus                       = 11
    	PDG_e_plus                        = -11
    	PDG_nu_e                          = 12
    	PDG_anti_nu_e                     = -12
    	PDG_mu_minus                      = 13
    	PDG_mu_plus                       = -13
    	PDG_nu_mu                         = 14
    	PDG_anti_nu_mu                    = -14
    	PDG_tau_minus                     = 15
    	PDG_tau_plus                      = -15
    	PDG_nu_tau                        = 16
    	PDG_anti_nu_tau                   = -16
    	PDG_L_minus                       = 17
    	PDG_L_plus                        = -17
    	PDG_nu_L                          = 18
    	PDG_anti_nu_L                     = -18
    	PDG_gamma                         = 22
    	PDG_Z0                            = 23
    	PDG_W_plus                        = 24
    	PDG_W_minus                       = -24
    	PDG_Higgs0                        = 25
    	PDG_reggeon                       = 28
    	PDG_pomeron                       = 29
    	PDG_Z_prime0                      = 32
    	PDG_Z_prime_prime0                = 33
    	PDG_W_prime_plus                  = 34
    	PDG_W_prime_minus                 = -34
    	PDG_Higgs_prime0                  = 35
    	PDG_A0                            = 36
    	PDG_Higgs_plus                    = 37
    	PDG_Higgs_minus                   = -37
    	PDG_R0                            = 40
    	PDG_anti_R0                       = -40
    	PDG_specflav                      = 81
    	PDG_rndmflav                      = 82
    	PDG_anti_rndmflav                 = -82
    	PDG_phasespa                      = 83
    	PDG_c_minushadron                 = 84
    	PDG_anti_c_minushadron            = -84
    	PDG_b_minushadron                 = 85
    	PDG_anti_b_minushadron            = -85
    	PDG_t_minushadron                 = 86
    	PDG_anti_t_minushadron            = -86
    	PDG_Wvirt_plus                    = 89
    	PDG_Wvirt_minus                   = -89
    	PDG_diquark                       = 90
    	PDG_anti_diquark                  = -90
    	PDG_cluster                       = 91
    	PDG_string                        = 92
    	PDG_indep                         = 93
    	PDG_CMshower                      = 94
    	PDG_SPHEaxis                      = 95
    	PDG_THRUaxis                      = 96
    	PDG_CLUSjet                       = 97
    	PDG_CELLjet                       = 98
    	PDG_table                         = 99
    	PDG_pi0                           = 111
    	PDG_pi_plus                       = 211
    	PDG_pi_minus                      = -211
    	PDG_pi_diffr_plus                 = 210
    	PDG_pi_diffr_minus                = -210
    	PDG_pi_2S0                        = 20111
    	PDG_pi_2S_plus                    = 20211
    	PDG_pi_2S_minus                   = -20211
    	PDG_eta                           = 221
    	PDG_eta_2S                        = 20221
    	PDG_eta_prime                     = 331
    	PDG_rho0                          = 113
    	PDG_rho_plus                      = 213
    	PDG_rho_minus                     = -213
    	PDG_rho_2S0                       = 30113
    	PDG_rho_2S_plus                   = 30213
    	PDG_rho_2S_minus                  = -30213
    	PDG_rho_3S0                       = 40113
    	PDG_rho_3S_plus                   = 40213
    	PDG_rho_3S_minus                  = -40213
    	PDG_omega                         = 223
    	PDG_omega_2S                      = 30223
    	PDG_phi                           = 333
    	PDG_a_00                          = 10111
    	PDG_a_0_plus                      = 10211
    	PDG_a_0_minus                     = -10211
    	PDG_f_0                           = 10221
    	PDG_f_prime_0                     = 10331
    	PDG_b_10                          = 10113
    	PDG_b_1_plus                      = 10213
    	PDG_b_1_minus                     = -10213
    	PDG_h_1                           = 10223
    	PDG_h_prime_1                     = 10333
    	PDG_a_10                          = 20113
    	PDG_a_1_plus                      = 20213
    	PDG_a_1_minus                     = -20213
    	PDG_f_1                           = 20223
    	PDG_f_prime_1                     = 20333
    	PDG_a_20                          = 115
    	PDG_a_2_plus                      = 215
    	PDG_a_2_minus                     = -215
    	PDG_f_2                           = 225
    	PDG_f_prime_2                     = 335
    	PDG_K0                            = 311
    	PDG_anti_K0                       = -311
    	PDG_K_S0                          = 310
    	PDG_K_L0                          = 130
    	PDG_K_plus                        = 321
    	PDG_K_minus                       = -321
    	PDG_K_star0                       = 313
    	PDG_anti_K_star0                  = -313
    	PDG_K_star_plus                   = 323
    	PDG_K_star_minus                  = -323
    	PDG_K_0_star0                     = 10311
    	PDG_anti_K_0_star0                = -10311
    	PDG_K_0_star_plus                 = 10321
    	PDG_K_0_star_minus                = -10321
    	PDG_K_10                          = 10313
    	PDG_anti_K_10                     = -10313
    	PDG_K_1_plus                      = 10323
    	PDG_K_1_minus                     = -10323
    	PDG_K_2_star0                     = 315
    	PDG_anti_K_2_star0                = -315
    	PDG_K_2_star_plus                 = 325
    	PDG_K_2_star_minus                = -325
    	PDG_K_prime_10                    = 20313
    	PDG_anti_K_prime_10               = -20313
    	PDG_K_prime_1_plus                = 20323
    	PDG_K_prime_1_minus               = -20323
    	PDG_D_plus                        = 411
    	PDG_D_minus                       = -411
    	PDG_D0                            = 421
    	PDG_anti_D0                       = -421
    	PDG_D_star_plus                   = 413
    	PDG_D_star_minus                  = -413
    	PDG_D_star0                       = 423
    	PDG_anti_D_star0                  = -423
    	PDG_D_0_star_plus                 = 10411
    	PDG_D_0_star_minus                = -10411
    	PDG_D_0_star0                     = 10421
    	PDG_anti_D_0_star0                = -10421
    	PDG_D_1_plus                      = 10413
    	PDG_D_1_minus                     = -10413
    	PDG_D_10                          = 10423
    	PDG_anti_D_10                     = -10423
    	PDG_D_2_star_plus                 = 415
    	PDG_D_2_star_minus                = -415
    	PDG_D_2_star0                     = 425
    	PDG_anti_D_2_star0                = -425
    	PDG_D_prime_1_plus                = 20413
    	PDG_D_prime_1_minus               = -20413
    	PDG_D_prime_10                    = 20423
    	PDG_anti_D_prime_10               = -20423
    	PDG_D_s_plus                      = 431
    	PDG_D_s_minus                     = -431
    	PDG_D_s_star_plus                 = 433
    	PDG_D_s_star_minus                = -433
    	PDG_D_s0_star_plus                = 10431
    	PDG_D_s0_star_minus               = -10431
    	PDG_D_s1_plus                     = 10433
    	PDG_D_s1_minus                    = -10433
    	PDG_D_s2_star_plus                = 435
    	PDG_D_s2_star_minus               = -435
    	PDG_D_prime_s1_plus               = 20433
    	PDG_D_prime_s1_minus              = -20433
    	PDG_B0                            = 511
    	PDG_anti_B0                       = -511
    	PDG_B_plus                        = 521
    	PDG_B_minus                       = -521
    	PDG_B_star0                       = 513
    	PDG_anti_B_star0                  = -513
    	PDG_B_star_plus                   = 523
    	PDG_B_star_minus                  = -523
    	PDG_B_0_star0                     = 10511
    	PDG_anti_B_0_star0                = -10511
    	PDG_B_0_star_plus                 = 10521
    	PDG_B_0_star_minus                = -10521
    	PDG_B_10                          = 10513
    	PDG_anti_B_10                     = -10513
    	PDG_B_1_plus                      = 10523
    	PDG_B_1_minus                     = -10523
    	PDG_B_2_star0                     = 515
    	PDG_anti_B_2_star0                = -515
    	PDG_B_2_star_plus                 = 525
    	PDG_B_2_star_minus                = -525
    	PDG_B_prime_10                    = 20513
    	PDG_anti_B_prime_10               = -20513
    	PDG_B_prime_1_plus                = 20523
    	PDG_B_prime_1_minus               = -20523
    	PDG_B_s0                          = 531
    	PDG_anti_B_s0                     = -531
    	PDG_B_s_star0                     = 533
    	PDG_anti_B_s_star0                = -533
    	PDG_B_s0_star0                    = 10531
    	PDG_anti_B_s0_star0               = -10531
    	PDG_B_s10                         = 10533
    	PDG_anti_B_s10                    = -10533
    	PDG_B_s2_star0                    = 535
    	PDG_anti_B_s2_star0               = -535
    	PDG_B_prime_s10                   = 20533
    	PDG_anti_B_prime_s10              = -20533
    	PDG_B_c_plus                      = 541
    	PDG_B_c_minus                     = -541
    	PDG_B_c_star_plus                 = 543
    	PDG_B_c_star_minus                = -543
    	PDG_B_c0_star_plus                = 10541
    	PDG_B_c0_star_minus               = -10541
    	PDG_B_c1_plus                     = 10543
    	PDG_B_c1_minus                    = -10543
    	PDG_B_c2_star_plus                = 545
    	PDG_B_c2_star_minus               = -545
    	PDG_B_prime_c1_plus               = 20543
    	PDG_B_prime_c1_minus              = -20543
    	PDG_eta_c                         = 441
    	PDG_eta_c_2S                      = 20441
    	PDG_J_psi                         = 443
    	PDG_psi_2S                        = 20443
    	PDG_chi_c0                        = 10441
    	PDG_chi_c1                        = 10443
    	PDG_chi_c2                        = 445
    	PDG_eta_b_2S                      = 20551
    	PDG_eta_b_3S                      = 40551
    	PDG_Upsilon                       = 553
    	PDG_Upsilon_2S                    = 20553
    	PDG_Upsilon_3S                    = 60553
    	PDG_Upsilon_4S                    = 70553
    	PDG_Upsilon_5S                    = 80553
    	PDG_h_b                           = 10553
    	PDG_h_b_2P                        = 40553
    	PDG_h_b_3P                        = 100553
    	PDG_chi_b0                        = 551
    	PDG_chi_b1                        = 20553
    	PDG_chi_b2                        = 555
    	PDG_chi_b0_2P                     = 30551
    	PDG_chi_b1_2P                     = 50553
    	PDG_chi_b2_2P                     = 10555
    	PDG_chi_b0_3P                     = 50551
    	PDG_chi_b1_3P                     = 110553
    	PDG_chi_b2_3P                     = 20555
    	PDG_eta_b2_1D                     = 40555
    	PDG_eta_b2_2D                     = 60555
    	PDG_Upsilon_1_1D                  = 120553
    	PDG_Upsilon_2_1D                  = 30555
    	PDG_Upsilon_3_1D                  = 557
    	PDG_Upsilon_1_2D                  = 130553
    	PDG_Upsilon_2_2D                  = 50555
    	PDG_Upsilon_3_2D                  = 10557
    	PDG_Delta_minus                   = 1114
    	PDG_anti_Delta_plus               = -1114
    	PDG_n_diffr                       = 2110
    	PDG_anti_n_diffr                  = -2110
    	PDG_n0                            = 2112
    	PDG_anti_n0                       = -2112
    	PDG_Delta0                        = 2114
    	PDG_anti_Delta0                   = -2114
    	PDG_p_diffr_plus                  = 2210
    	PDG_anti_p_diffr_minus            = -2210
    	PDG_p_plus                        = 2212
    	PDG_anti_p_minus                  = -2212
    	PDG_Delta_plus                    = 2214
    	PDG_anti_Delta_minus              = -2214
    	PDG_Delta_plus_plus               = 2224
    	PDG_anti_Delta_minus_minus        = -2224
    	PDG_Sigma_minus                   = 3112
    	PDG_anti_Sigma_plus               = -3112
    	PDG_Sigma_star_minus              = 3114
    	PDG_anti_Sigma_star_plus          = -3114
    	PDG_Lambda0                       = 3122
    	PDG_anti_Lambda0                  = -3122
    	PDG_Sigma0                        = 3212
    	PDG_anti_Sigma0                   = -3212
    	PDG_Sigma_star0                   = 3214
    	PDG_anti_Sigma_star0              = -3214
    	PDG_Sigma_plus                    = 3222
    	PDG_anti_Sigma_minus              = -3222
    	PDG_Sigma_star_plus               = 3224
    	PDG_anti_Sigma_star_minus         = -3224
    	PDG_Xi_minus                      = 3312
    	PDG_anti_Xi_plus                  = -3312
    	PDG_Xi_star_minus                 = 3314
    	PDG_anti_Xi_star_plus             = -3314
    	PDG_Xi0                           = 3322
    	PDG_anti_Xi0                      = -3322
    	PDG_Xi_star0                      = 3324
    	PDG_anti_Xi_star0                 = -3324
    	PDG_Omega_minus                   = 3334
    	PDG_anti_Omega_plus               = -3334
    	PDG_Sigma_c0                      = 4112
    	PDG_anti_Sigma_c0                 = -4112
    	PDG_Sigma_c_star0                 = 4114
    	PDG_anti_Sigma_c_star0            = -4114
    	PDG_Lambda_c_plus                 = 4122
    	PDG_anti_Lambda_c_minus           = -4122
    	PDG_Xi_c0                         = 4132
    	PDG_anti_Xi_c0                    = -4132
    	PDG_Sigma_c_plus                  = 4212
    	PDG_anti_Sigma_c_minus            = -4212
    	PDG_Sigma_c_star_plus             = 4214
    	PDG_anti_Sigma_c_star_minus       = -4214
    	PDG_Sigma_c_plus_plus             = 4222
    	PDG_anti_Sigma_c_minus_minus      = -4222
    	PDG_Sigma_c_star_plus_plus        = 4224
    	PDG_anti_Sigma_c_star_minus_minus = -4224
    	PDG_Xi_c_plus                     = 4322
    	PDG_anti_Xi_c_minus               = -4322
    	PDG_Xi_prime_c0                   = 4312
    	PDG_Xi_primeanti__c0              = -4312
    	PDG_Xi_c_star0                    = 4314
    	PDG_anti_Xi_c_star0               = -4314
    	PDG_Xi_prime_c_plus               = 4232
    	PDG_Xi_primeanti__c_minus         = -4232
    	PDG_Xi_c_star_plus                = 4324
    	PDG_anti_Xi_c_star_minus          = -4324
    	PDG_Omega_c0                      = 4332
    	PDG_anti_Omega_c0                 = -4332
    	PDG_Omega_c_star0                 = 4334
    	PDG_anti_Omega_c_star0            = -4334
    	PDG_Sigma_b_minus                 = 5112
    	PDG_anti_Sigma_b_plus             = -5112
    	PDG_Sigma_b_star_minus            = 5114
    	PDG_anti_Sigma_b_star_plus        = -5114
    	PDG_Lambda_b0                     = 5122
    	PDG_anti_Lambda_b0                = -5122
    	PDG_Xi_b_minus                    = 5132
    	PDG_anti_Xi_b_plus                = -5132
    	PDG_Sigma_b0                      = 5212
    	PDG_anti_Sigma_b0                 = -5212
    	PDG_Sigma_b_star0                 = 5214
    	PDG_anti_Sigma_b_star0            = -5214
    	PDG_Sigma_b_plus                  = 5222
    	PDG_anti_Sigma_b_minus            = -5222
    	PDG_Sigma_star_                   = 5224
    	PDG_anti_Sigma_b_star_minus       = -5224
    	PDG_Xi_b0                         = 5232
    	PDG_anti_Xi_b0                    = -5232
    	PDG_Xi_prime_b_minus              = 5312
    	PDG_anti_Xi_prime_b_plus          = -5312
    	PDG_Xi_b_star_minus               = 5314
    	PDG_anti_Xi_b_star_plus           = -5314
    	PDG_Xi_prime_b0                   = 5322
    	PDG_anti_Xi_prime_b0              = -5322
    	PDG_Xi_b_star0                    = 5324
    	PDG_anti_Xi_b_star0               = -5324
    	PDG_Omega_b_minus                 = 5332
    	PDG_anti_Omega_b_plus             = -5332
    	PDG_Omega_b_star_minus            = 5334
    	PDG_anti_Omega_b_star_plus        = -5334
    	PDG_dd_0                          = 1101
    	PDG_anti_dd_0                     = -1101
    	PDG_ud_0                          = 2101
    	PDG_anti_ud_0                     = -2101
    	PDG_uu_0                          = 2201
    	PDG_anti_uu_0                     = -2201
    	PDG_sd_0                          = 3101
    	PDG_anti_sd_0                     = -3101
    	PDG_su_0                          = 3201
    	PDG_anti_su_0                     = -3201
    	PDG_ss_0                          = 3301
    	PDG_anti_ss_0                     = -3301
    	PDG_cd_0                          = 4101
    	PDG_anti_cd_0                     = -4101
    	PDG_cu_0                          = 4201
    	PDG_anti_cu_0                     = -4201
    	PDG_cs_0                          = 4301
    	PDG_anti_cs_0                     = -4301
    	PDG_cc_0                          = 4401
    	PDG_anti_cc_0                     = -4401
    	PDG_bd_0                          = 5101
    	PDG_anti_bd_0                     = -5101
    	PDG_bu_0                          = 5201
    	PDG_anti_bu_0                     = -5201
    	PDG_bs_0                          = 5301
    	PDG_anti_bs_0                     = -5301
    	PDG_bc_0                          = 5401
    	PDG_anti_bc_0                     = -5401
    	PDG_bb_0                          = 5501
    	PDG_anti_bb_0                     = -5501
    	PDG_dd_1                          = 1103
    	PDG_anti_dd_1                     = -1103
    	PDG_ud_1                          = 2103
    	PDG_anti_ud_1                     = -2103
    	PDG_uu_1                          = 2203
    	PDG_anti_uu_1                     = -2203
    	PDG_sd_1                          = 3103
    	PDG_anti_sd_1                     = -3103
    	PDG_su_1                          = 3203
    	PDG_anti_su_1                     = -3203
    	PDG_ss_1                          = 3303
    	PDG_anti_ss_1                     = -3303
    	PDG_cd_1                          = 4103
    	PDG_anti_cd_1                     = -4103
    	PDG_cu_1                          = 4203
    	PDG_anti_cu_1                     = -4203
    	PDG_cs_1                          = 4303
    	PDG_anti_cs_1                     = -4303
    	PDG_cc_1                          = 4403
    	PDG_anti_cc_1                     = -4403
    	PDG_bd_1                          = 5103
    	PDG_anti_bd_1                     = -5103
    	PDG_bu_1                          = 5203
    	PDG_anti_bu_1                     = -5203
    	PDG_bs_1                          = 5303
    	PDG_anti_bs_1                     = -5303
    	PDG_bc_1                          = 5403
    	PDG_anti_bc_1                     = -5403
    	PDG_bb_1                          = 5503
    	PDG_anti_bb_1                     = -5503
    
    	PDG_s_e_minus_L = 1000011
    	PDG_s_e_plus_L  = -1000011
    
    	PDG_s_nu_e_L      = 1000012
    	PDG_s_anti_nu_e_L = -1000012
    
    	PDG_s_mu_minus_L = 1000013
    	PDG_s_mu_plus_L  = -1000013
    
    	PDG_s_nu_mu_L      = 1000014
    	PDG_s_anti_nu_mu_L = -1000014
    
    	// L-R mixing significant, use _1 and _2 for names instead
    	PDG_s_tau_minus_1 = 1000015
    	PDG_s_tau_plus_1  = -1000015
    
    	PDG_s_nu_tau_L         = 1000016
    	PDG_s_anti_nu_tau_Lint = -1000016
    
    	PDG_s_e_minus_R = 2000011
    	PDG_s_e_plus_R  = -2000011
    
    	PDG_s_mu_minus_R = 2000013
    	PDG_s_mu_plus_R  = -2000013
    
    	PDG_s_tau_minus_2 = 2000015
    	PDG_s_tau_plus_2  = -2000015
    
    	PDG_s_g = 1000021
    
    	PDG_s_chi_0_1 = 1000022
    
    	PDG_s_chi_0_2 = 1000023
    
    	PDG_s_chi_plus_1  = 1000024
    	PDG_s_chi_minus_1 = -1000024 // Majorana
    
    	PDG_s_chi_0_3 = 1000025
    
    	PDG_s_chi_0_4 = 1000035
    
    	PDG_s_chi_plus_2  = 1000037
    	PDG_s_chi_minus_2 = -1000037
    
    	PDG_s_G = 1000039
    
    	// doubly charged Higgs
    	PDG_Higgs_plus_plus_L   = 9900041
    	PDG_Higgs_minus_minus_L = -9900041
    	PDG_Higgs_plus_plus_R   = 9900042
    	PDG_Higgs_minus_minus_R = -9900042
    
    	/// Null particles
    	PDG_deuteron = 0
    	PDG_tritium  = 0
    	PDG_alpha    = 0
    	PDG_geantino = 0
    	PDG_He3      = 0
    	PDG_Cerenkov = 0
    	PDG_null     = 0
    )
    View Source
    const (
    	Nj location
    	Nq3
    	Nq2
    	Nq1
    	Nl
    	Nr
    	N
    	N8
    	N9
    	N10
    )

      PID digits (base 10) are: n Nr Nl Nq1 Nq2 Nq3 Nj The location enum provides a convenient index into the PID.

      Variables

      This section is empty.

      Functions

      func Len

      func Len() int

        Len returns the size of the default particle data table

        func Name

        func Name() string

          Name returns the name of the default particle data table

          func PDT

          func PDT() map[PID]*Particle

            PDT returns the default particle data table content

            Types

            type Constituent

            type Constituent struct {
            	ID  PID // particle ID
            	Mul int // multiplicity
            }

              Constituent holds a particle constituent (e.g. quark type and number of quarks of this type)

              func (Constituent) IsBottom

              func (c Constituent) IsBottom() bool

                IsBottom returns whether this is a bottom-quark

                func (Constituent) IsCharm

                func (c Constituent) IsCharm() bool

                  IsCharm returns whether this is a charm-quark

                  func (Constituent) IsDown

                  func (c Constituent) IsDown() bool

                    IsDown returns whether this is a down-quark

                    func (Constituent) IsStrange

                    func (c Constituent) IsStrange() bool

                      IsStrange returns whether this is a strqnge-quark

                      func (Constituent) IsTop

                      func (c Constituent) IsTop() bool

                        IsTop returns whether this is a top-quark

                        func (Constituent) IsUp

                        func (c Constituent) IsUp() bool

                          IsUp returns whether this is an up-quark

                          type Measurement

                          type Measurement struct {
                          	Value float64
                          	Sigma float64
                          }

                            Measurement holds a value and its associated error

                            type PID

                            type PID int

                              Particle Identification number In the standard numbering scheme, the PID digits (base 10) are:

                              +/- n Nr Nl Nq1 Nq2 Nq3 Nj
                              

                              It is expected that any 7 digit number used as a PID will adhere to the Monte Carlo numbering scheme documented by the PDG. Note that particles not already explicitly defined can be expressed within this numbering scheme.

                              func (PID) A

                              func (pid PID) A() int

                                A returns A if this is a nucleus

                                func (PID) AbsPID

                                func (pid PID) AbsPID() int

                                  AbsPID returns the absolute value of the particle ID

                                  func (PID) Charge

                                  func (pid PID) Charge() float64

                                    Charge returns the actual charge which might be fractional

                                    func (PID) Digit

                                    func (pid PID) Digit(loc location) int

                                      Digit splits the PID into constituent integers

                                      func (PID) ExtraBits

                                      func (pid PID) ExtraBits() int

                                        ExtraBits returns everything beyoind the 7th digit (e.g. outside the numbering scheme)

                                        func (PID) FundamentalID

                                        func (pid PID) FundamentalID() int

                                          FundamentalID returns the first 2 digits if this is a "fundamental" particle. ID==100 is a special case (internal generator ID's are 81-100) Also, 101 and 102 are now used for geantinos

                                          func (PID) HasBottom

                                          func (pid PID) HasBottom() bool

                                            HasBottom returns whether this particle contains a bottom quark

                                            func (PID) HasCharm

                                            func (pid PID) HasCharm() bool

                                              HasCharm returns whether this particle contains a charm quark

                                              func (PID) HasDown

                                              func (pid PID) HasDown() bool

                                                HasDown returns whether this particle contains a down quark

                                                func (PID) HasStrange

                                                func (pid PID) HasStrange() bool

                                                  HasStrange returns whether this particle contains a strange quark

                                                  func (PID) HasTop

                                                  func (pid PID) HasTop() bool

                                                    HasTop returns whether this particle contains a top quark

                                                    func (PID) HasUp

                                                    func (pid PID) HasUp() bool

                                                      HasUp returns whether this particle contains an up quark

                                                      func (PID) IsBaryon

                                                      func (pid PID) IsBaryon() bool

                                                        IsBaryon returns whether this is a valid baryon id

                                                        func (PID) IsDiQuark

                                                        func (pid PID) IsDiQuark() bool

                                                          IsDiQuark returns whether this is a valid diquark id

                                                          func (PID) IsDyon

                                                          func (pid PID) IsDyon() bool

                                                            IsDyon returns whether this is a valid Dyon (magnetic monopole) id

                                                            func (PID) IsHadron

                                                            func (pid PID) IsHadron() bool

                                                              IsHadron returns whether this is a valid hadron id

                                                              func (PID) IsLepton

                                                              func (pid PID) IsLepton() bool

                                                                IsLepton returns whether this is a valid lepton id

                                                                func (PID) IsMeson

                                                                func (pid PID) IsMeson() bool

                                                                  IsMeson returns whether this is a valid meson ID

                                                                  func (PID) IsNucleus

                                                                  func (pid PID) IsNucleus() bool

                                                                    IsNucleus returns whether this is a valid nucleus id. This implements the 2006 Monte Carlon nuclear code scheme. Ion numbers are +/- 10LZZZAAAI. AAA is A - total baryon number ZZZ is Z - total charge L is the total number of strange quarks. I is the isomer number, with I=0 corresponding to the ground state.

                                                                    func (PID) IsPentaquark

                                                                    func (pid PID) IsPentaquark() bool

                                                                      IsPentaquark returns whether this is a valid pentaquark id

                                                                      func (PID) IsQBall

                                                                      func (pid PID) IsQBall() bool

                                                                        IsQBall checks for QBall or any exotic particle with electric charge beyond the qqq scheme. Ad-hoc numbering for such particles is 100xxxx0, where xxxx is the charge in tenths.

                                                                        func (PID) IsRhadron

                                                                        func (pid PID) IsRhadron() bool

                                                                          IsRhadron returns whether this is a valid R-hadron particle id

                                                                          func (PID) IsSUSY

                                                                          func (pid PID) IsSUSY() bool

                                                                            IsSUSY returns whether this is a valid SUSY particle id

                                                                            func (PID) IsValid

                                                                            func (pid PID) IsValid() bool

                                                                              IsValid returns whether PID is a valid particle ID

                                                                              func (PID) JSpin

                                                                              func (pid PID) JSpin() int

                                                                                JSpin returns 2J+1, where J is the total spin

                                                                                func (PID) LSpin

                                                                                func (pid PID) LSpin() int

                                                                                  LSpin returns the orbital angular momentum. Valid for mesons only

                                                                                  func (PID) Lambda

                                                                                  func (pid PID) Lambda() int

                                                                                    Lambda returns lambda if this is a nucleus

                                                                                    func (PID) Quarks

                                                                                    func (pid PID) Quarks() Quarks

                                                                                      Quarks returns a list of 3 constituent quarks

                                                                                      func (PID) SSpin

                                                                                      func (pid PID) SSpin() int

                                                                                        SSpin returns the spin. Valid for mesons only

                                                                                        func (PID) Z

                                                                                        func (pid PID) Z() int

                                                                                          Z returns Z if this is a nucleus

                                                                                          type Particle

                                                                                          type Particle struct {
                                                                                          	ID          PID           // particle ID
                                                                                          	Name        string        // particle name
                                                                                          	PDG         int           // PDG code of the particle
                                                                                          	Mass        float64       // particle mass in GeV
                                                                                          	Charge      float64       // electrical charge
                                                                                          	ColorCharge float64       // color charge
                                                                                          	Spin        SpinState     // spin state
                                                                                          	Quarks      []Constituent // constituents
                                                                                          	Resonance   Resonance     // resonance
                                                                                          }

                                                                                            Particle holds informations on a particle as per the PDG booklet

                                                                                            func ParticleByID

                                                                                            func ParticleByID(pid PID) *Particle

                                                                                              ParticleByID returns the particle information via particle ID

                                                                                              func ParticleByName

                                                                                              func ParticleByName(n string) *Particle

                                                                                                ParticleByName returns the particle information via particle name

                                                                                                func (*Particle) IsStable

                                                                                                func (p *Particle) IsStable() bool

                                                                                                  IsStable returns whether this particle is stable

                                                                                                  type Quarks

                                                                                                  type Quarks struct {
                                                                                                  	Nq1 int16
                                                                                                  	Nq2 int16
                                                                                                  	Nq3 int16
                                                                                                  }

                                                                                                    Quarks describes a given quark mixture

                                                                                                    type Resonance

                                                                                                    type Resonance struct {
                                                                                                    	Mass  Measurement // mass measurement
                                                                                                    	Width Measurement // total width measurement
                                                                                                    	Lower float64     // lower cutoff of allowed width values
                                                                                                    	Upper float64     // upper cutoff of allowed width values
                                                                                                    }

                                                                                                      Resonance holds mass and width informations for a Breit-Wigner distribution about a given mass

                                                                                                      func (*Resonance) Lifetime

                                                                                                      func (r *Resonance) Lifetime() Measurement

                                                                                                        Lifetime computes and returns the lifetime from the total width

                                                                                                        func (*Resonance) SetTotalWidthFromLifetime

                                                                                                        func (r *Resonance) SetTotalWidthFromLifetime(lifetime Measurement)

                                                                                                        type SpinState

                                                                                                        type SpinState struct {
                                                                                                        	TotalSpin float64 // total spin
                                                                                                        	Spin      float64
                                                                                                        	OrbAngMom float64 // orbital angular momentum
                                                                                                        }

                                                                                                          SpinState contains the total spin, spin and orbital angular momentum

                                                                                                          type Table

                                                                                                          type Table struct {
                                                                                                          	// contains filtered or unexported fields
                                                                                                          }

                                                                                                            Table represents a particle data table.

                                                                                                            func New

                                                                                                            func New(r io.Reader, n string) (Table, error)

                                                                                                              New returns a new particle data table, initialized from r

                                                                                                              func (*Table) Len

                                                                                                              func (t *Table) Len() int

                                                                                                                Len returns the size of the particle data table

                                                                                                                func (*Table) Name

                                                                                                                func (t *Table) Name() string

                                                                                                                  Name returns the name of this particle data table

                                                                                                                  func (*Table) PDT

                                                                                                                  func (t *Table) PDT() map[PID]*Particle

                                                                                                                    PDT returns the particle data table

                                                                                                                    func (*Table) ParticleByID

                                                                                                                    func (t *Table) ParticleByID(pid PID) *Particle

                                                                                                                      ParticleByID returns the particle information via particle ID

                                                                                                                      func (*Table) ParticleByName

                                                                                                                      func (t *Table) ParticleByName(n string) *Particle

                                                                                                                        ParticleByName returns the particle information via particle name