PDGUtils.cxx
Go to the documentation of this file.
1 //____________________________________________________________________________
2 /*
3  Copyright (c) 2003-2019, The GENIE Collaboration
4  For the full text of the license visit http://copyright.genie-mc.org
5  or see $GENIE/LICENSE
6 
7  Author: Costas Andreopoulos <costas.andreopoulos \at stfc.ac.uk>
8  University of Liverpool & STFC Rutherford Appleton Lab
9 
10  Changes required to implement the GENIE Boosted Dark Matter module
11  were installed by Josh Berger (Univ. of Wisconsin)
12 */
13 //____________________________________________________________________________
14 
15 #include <cassert>
16 
21 
22 using namespace genie;
23 
24 //____________________________________________________________________________
26 {
27 // ROOT's rootino has PDG code=0
28 // GENIE pseudoparticles are in the 2000000000-2000100000 range
29 // Include PYTHIA's pseudoparticles
30 
31  bool is_fake =
32  ( (pdgc == 0) ||
33  (pdgc > 2000000000 && pdgc < 2000100000) ||
34  (pdgc == kPdgCluster || pdgc == kPdgString || pdgc == kPdgIndep)
35  );
36 
37  return is_fake;
38 }
39 //____________________________________________________________________________
40 bool genie::pdg::IsIon(int pdgc)
41 {
42  return (pdgc > 1000000000 && pdgc < 1999999999);
43 }
44 //____________________________________________________________________________
45 bool genie::pdg::IsParticle(int pdgc)
46 {
47  if( genie::pdg::IsPseudoParticle (pdgc) ) return false;
48  if( genie::pdg::IsIon (pdgc) ) return false;
49 
50  return true;
51 }
52 //____________________________________________________________________________
53 int genie::pdg::IonPdgCodeToZ(int ion_pdgc)
54 {
55 // Decoding Z from the PDG code (PDG ion code convention: 10LZZZAAAI)
56 
57  int Z = (ion_pdgc/10000) - 1000*(ion_pdgc/10000000); // don't factor out!
58  return Z;
59 }
60 //____________________________________________________________________________
61 int genie::pdg::IonPdgCodeToA(int ion_pdgc)
62 {
63 // Decoding A from the PDG code (PDG ion code convention: 10LZZZAAAI)
64 
65  int A = (ion_pdgc/10) - 1000*(ion_pdgc/10000); // don't factor out!
66  return A;
67 }
68 //____________________________________________________________________________
69 int genie::pdg::IonPdgCode(int A, int Z)
70 {
71 // Build ion PDG code from A,Z
72 
73  return IonPdgCode(A,Z,0,0);
74 }
75 //____________________________________________________________________________
76 int genie::pdg::IonPdgCode(int A, int Z, int L, int I)
77 {
78 // Build ion PDG code from A,Z,L,I
79 
80  int ion_pdgc = 1000000000 + L*100000000 + Z*10000 + A*10 + I;
81  return ion_pdgc;
82 }
83 //____________________________________________________________________________
84 bool genie::pdg::IsLepton(int pdgc)
85 {
86  bool is_neutral_lepton = genie::pdg::IsNeutralLepton(pdgc);
87  bool is_charged_lepton = genie::pdg::IsChargedLepton(pdgc);
88 
89  bool is_lepton = (is_neutral_lepton || is_charged_lepton);
90  return is_lepton;
91 }
92 //____________________________________________________________________________
94 {
95  bool is_neutral_lepton = IsNeutrino(pdgc) || IsAntiNeutrino(pdgc);
96  return is_neutral_lepton;
97 }
98 //____________________________________________________________________________
100 {
101  bool is_neg_lepton = genie::pdg::IsNegChargedLepton(pdgc);
102  bool is_pos_lepton = genie::pdg::IsPosChargedLepton(pdgc);
103 
104  bool is_charged_lepton = is_neg_lepton || is_pos_lepton;
105  return is_charged_lepton;
106 }
107 //____________________________________________________________________________
109 {
110  bool is_nu = (pdgc == kPdgNuE) ||
111  (pdgc == kPdgNuMu) ||
112  (pdgc == kPdgNuTau);
113  return is_nu;
114 }
115 //____________________________________________________________________________
117 {
118  bool is_nubar = (pdgc == kPdgAntiNuE) ||
119  (pdgc == kPdgAntiNuMu) ||
120  (pdgc == kPdgAntiNuTau);
121 
122  return is_nubar;
123 }
124 //____________________________________________________________________________
126 {
127  bool is_dm = (pdgc == kPdgDarkMatter);
128  return is_dm;
129 }
130 //____________________________________________________________________________
132 {
133  bool is_neg_lepton = (pdgc == kPdgElectron) ||
134  (pdgc == kPdgMuon) ||
135  (pdgc == kPdgTau);
136 
137  return is_neg_lepton;
138 }
139 //____________________________________________________________________________
141 {
142  bool is_pos_lepton = (pdgc == kPdgPositron) ||
143  (pdgc == kPdgAntiMuon) ||
144  (pdgc == kPdgAntiTau);
145 
146  return is_pos_lepton;
147 }
148 //____________________________________________________________________________
149 
150 bool genie::pdg::IsNuE(int pdgc)
151 {
152  return (pdgc == kPdgNuE);
153 }
154 //____________________________________________________________________________
155 bool genie::pdg::IsNuMu(int pdgc)
156 {
157  return (pdgc == kPdgNuMu);
158 }
159 //____________________________________________________________________________
160 bool genie::pdg::IsNuTau(int pdgc)
161 {
162  return (pdgc == kPdgNuTau);
163 }
164 //____________________________________________________________________________
165 bool genie::pdg::IsAntiNuE(int pdgc)
166 {
167  return (pdgc == kPdgAntiNuE);
168 }
169 //____________________________________________________________________________
171 {
172  return (pdgc == kPdgAntiNuMu);
173 }
174 //____________________________________________________________________________
176 {
177  return (pdgc == kPdgAntiNuTau);
178 }
179 //____________________________________________________________________________
181 {
182  return (pdgc == kPdgElectron);
183 }
184 //____________________________________________________________________________
186 {
187  return (pdgc == kPdgPositron);
188 }
189 //____________________________________________________________________________
190 bool genie::pdg::IsMuon(int pdgc)
191 {
192  return (pdgc == kPdgMuon);
193 }
194 //____________________________________________________________________________
196 {
197  return (pdgc == kPdgAntiMuon);
198 }
199 //____________________________________________________________________________
200 bool genie::pdg::IsTau(int pdgc)
201 {
202  return (pdgc == kPdgTau);
203 }
204 //____________________________________________________________________________
205 bool genie::pdg::IsAntiTau(int pdgc)
206 {
207  return (pdgc == kPdgAntiTau);
208 }
209 //____________________________________________________________________________
211 {
212  switch(pdgc) {
213  case (kPdgNuE) : return kPdgElectron; break;
214  case (kPdgAntiNuE) : return kPdgPositron; break;
215  case (kPdgNuMu) : return kPdgMuon; break;
216  case (kPdgAntiNuMu) : return kPdgAntiMuon; break;
217  case (kPdgNuTau) : return kPdgTau; break;
218  case (kPdgAntiNuTau): return kPdgAntiTau; break;
219  }
220  return -1;
221 }
222 //____________________________________________________________________________
223 bool genie::pdg::IsDiQuark(int pdgc)
224 {
225  return ( pdgc == kPdgDDDiquarkS1 || pdgc == kPdgUDDiquarkS0 ||
226  pdgc == kPdgUDDiquarkS1 || pdgc == kPdgUUDiquarkS1 ||
227  pdgc == kPdgSDDiquarkS0 || pdgc == kPdgSDDiquarkS1 ||
228  pdgc == kPdgSUDiquarkS0 || pdgc == kPdgSUDiquarkS1 ||
229  pdgc == kPdgSSDiquarkS1
230  );
231 }
232 //____________________________________________________________________________
233 bool genie::pdg::IsQuark(int pdgc)
234 {
235  return ( pdgc == kPdgDQuark || pdgc == kPdgUQuark ||
236  pdgc == kPdgSQuark || pdgc == kPdgCQuark ||
237  pdgc == kPdgBQuark || pdgc == kPdgTQuark
238  );
239 }
240 //____________________________________________________________________________
242 {
243  return ( pdgc == kPdgAntiDQuark || pdgc == kPdgAntiUQuark ||
244  pdgc == kPdgAntiSQuark || pdgc == kPdgAntiCQuark ||
245  pdgc == kPdgAntiBQuark || pdgc == kPdgAntiTQuark
246  );
247 }
248 //____________________________________________________________________________
249 bool genie::pdg::IsUQuark(int pdgc)
250 {
251  return (pdgc == kPdgUQuark);
252 }
253 //____________________________________________________________________________
254 bool genie::pdg::IsDQuark(int pdgc)
255 {
256  return (pdgc == kPdgDQuark);
257 }
258 //____________________________________________________________________________
259 bool genie::pdg::IsSQuark(int pdgc)
260 {
261  return (pdgc == kPdgSQuark);
262 }
263 //____________________________________________________________________________
264 bool genie::pdg::IsCQuark(int pdgc)
265 {
266  return (pdgc == kPdgCQuark);
267 }
268 //____________________________________________________________________________
270 {
271  return (pdgc == kPdgAntiUQuark);
272 }
273 //____________________________________________________________________________
275 {
276  return (pdgc == kPdgAntiDQuark);
277 }
278 //____________________________________________________________________________
280 {
281  return (pdgc == kPdgAntiSQuark);
282 }
283 //____________________________________________________________________________
285 {
286  return (pdgc == kPdgAntiCQuark);
287 }
288 //____________________________________________________________________________
289 bool genie::pdg::IsPion(int pdgc)
290 {
291  return (pdgc == kPdgPiP || pdgc == kPdgPi0 || pdgc == kPdgPiM);
292 }
293 //____________________________________________________________________________
294 bool genie::pdg::IsKaon(int pdgc)
295 {
296  return (pdgc == kPdgKP || pdgc == kPdgK0 || pdgc == kPdgKM);
297 }
298 //____________________________________________________________________________
299 bool genie::pdg::IsProton(int pdgc)
300 {
301  return (pdgc == kPdgProton);
302 }
303 //____________________________________________________________________________
304 bool genie::pdg::IsNeutron(int pdgc)
305 {
306  return (pdgc == kPdgNeutron);
307 }
308 //____________________________________________________________________________
309 bool genie::pdg::IsNucleon(int pdgc)
310 {
311  return (pdgc == kPdgNeutron || pdgc == kPdgProton);
312 }
313 //____________________________________________________________________________
315 {
316  return (pdgc == kPdgNeutron || pdgc == kPdgProton);
317 }
318 //____________________________________________________________________________
320 {
321  assert(IsProton(pdgc) || IsNeutron(pdgc));
322 
323  if (IsProton(pdgc)) return kPdgNeutron;
324  else return kPdgProton;
325 }
326 //____________________________________________________________________________
327 int genie::pdg::ModifyNucleonCluster(int pdgc, int dQ)
328 {
330 
331  if(pdgc == kPdgClusterNN) {
332  if (dQ == 0) { return kPdgClusterNN; }
333  else if (dQ == +1) { return kPdgClusterNP; }
334  else if (dQ == +2) { return kPdgClusterPP; }
335  else { return 0; }
336  }
337  else
338  if(pdgc == kPdgClusterNP) {
339  if (dQ == -1) { return kPdgClusterNN; }
340  else if (dQ == 0) { return kPdgClusterNP; }
341  else if (dQ == +1) { return kPdgClusterPP; }
342  else { return 0; }
343  }
344  else
345  if(pdgc == kPdgClusterPP) {
346  if (dQ == -2) { return kPdgClusterNN; }
347  else if (dQ == -1) { return kPdgClusterNP; }
348  else if (dQ == 0) { return kPdgClusterPP; }
349  else { return 0; }
350  }
351 
352  return 0;
353 }
354 //____________________________________________________________________________
355 bool genie::pdg::IsHadron(int pdgc)
356 {
357  return ((pdgc>=100 && pdgc<=9999) || (pdgc>=-9999 && pdgc<=-100));
358 }
359 //____________________________________________________________________________
361 {
362  return utils::res::IsBaryonResonance(pdgc);
363 }
364 //____________________________________________________________________________
366 {
367  return (
368  pdgc == kPdgClusterNN ||
369  pdgc == kPdgClusterNP ||
370  pdgc == kPdgClusterPP
371  );
372 }
373 //____________________________________________________________________________
374 int genie::pdg::GeantToPdg(int geant_code)
375 {
376  if(geant_code == 3) return kPdgElectron; // 11 / e-
377  if(geant_code == 2) return kPdgPositron; // -11 / e+
378  if(geant_code == 6) return kPdgMuon; // 13 / mu-
379  if(geant_code == 5) return kPdgAntiMuon; // -13 / mu+
380  if(geant_code == 34) return kPdgTau; // 15 / tau-
381  if(geant_code == 33) return kPdgAntiTau; // -15 / tau+
382  if(geant_code == 8) return kPdgPiP; // 211 / pi+
383  if(geant_code == 9) return kPdgPiM; // -211 / pi-
384  if(geant_code == 7) return kPdgPi0; // 111 / pi0
385  if(geant_code == 17) return kPdgEta; // 221 / eta
386  if(geant_code == 11) return kPdgKP; // 321 / K+
387  if(geant_code == 12) return kPdgKM; // -321 / K-
388  if(geant_code == 10) return kPdgK0L; // 130 / K0_{long}
389  if(geant_code == 16) return kPdgK0S; // 310 / K0_{short}
390  if(geant_code == 35) return kPdgDP; // 411 / D+
391  if(geant_code == 36) return kPdgDM; // -411 / D-
392  if(geant_code == 37) return kPdgD0; // 421 / D0
393  if(geant_code == 38) return kPdgAntiD0; // -421 / \bar{D0}
394  if(geant_code == 39) return kPdgDPs; // 431 / D+_{s}
395  if(geant_code == 40) return kPdgDMs; // -431 / D-_{s}
396  if(geant_code == 1) return kPdgGamma; // 22 / photon
397  if(geant_code == 44) return kPdgZ0; // 23 / Z
398  if(geant_code == 42) return kPdgWP; // 24 / W+
399  if(geant_code == 43) return kPdgWM; // -24 / W-
400  if(geant_code == 14) return kPdgProton; // 2212
401  if(geant_code == 15) return kPdgAntiProton; // -2212
402  if(geant_code == 13) return kPdgNeutron; // 2112
403  if(geant_code == 25) return kPdgAntiNeutron; // -2112
404  if(geant_code == 18) return kPdgLambda; // 3122 / Lambda
405  if(geant_code == 26) return kPdgAntiLambda; // -3122 / \bar{Lambda}
406  if(geant_code == 19) return kPdgSigmaP; // 3222 / Sigma+
407  if(geant_code == 20) return kPdgSigma0; // 3212 / Sigma0
408  if(geant_code == 21) return kPdgSigmaM; // 3112 / Sigma-
409  if(geant_code == 29) return kPdgAntiSigmaP; // -3112 / \bar{Sigma+}
410  if(geant_code == 28) return kPdgAntiSigma0; // -3212 / \bar{Sigma0}
411  if(geant_code == 27) return kPdgAntiSigmaM; // -3112 / \bar{Sigma-}
412  if(geant_code == 22) return kPdgXi0; // 3322 / Xi0
413  if(geant_code == 23) return kPdgXiM; // 3312 / Xi-
414  if(geant_code == 30) return kPdgAntiXi0; // -3322 / \bar{Xi0}
415  if(geant_code == 31) return kPdgAntiXiP; // -3312 / \bar{Xi+}
416  if(geant_code == 24) return kPdgOmegaM; // 3334 / Omega-
417  if(geant_code == 32) return kPdgAntiOmegaP; // -3334 / \bar{Omega+}
418 
419  // some rare Geant3 codes that don't really need definitions in PDGCodes.h
420  const int kPdgDeuteron = 1000010020; // pdg::IonPdgCode(2,1);
421  const int kPdgTritium = 1000010030; // pdg::IonPdgCode(3,1);
422  const int kPdgAlpha = 1000020040; // pdg::IonPdgCode(4,2);
423  const int kPdgHe3 = 1000020030; // pdg::IonPdgCode(3,2);
424  if(geant_code == 45) return kPdgDeuteron;
425  if(geant_code == 46) return kPdgTritium;
426  if(geant_code == 47) return kPdgAlpha;
427  if(geant_code == 49) return kPdgHe3;
428 
429  LOG("PDG", pWARN)
430  << "Can not convert geant code: " << geant_code << " to PDG";
431  return 0;
432 }
433 //____________________________________________________________________________
434 
const int kPdgAntiD0
Definition: PDGCodes.h:161
const int kPdgDPs
Definition: PDGCodes.h:162
const int kPdgUUDiquarkS1
Definition: PDGCodes.h:58
bool IsPion(int pdgc)
Definition: PDGUtils.cxx:289
bool IsNuTau(int pdgc)
Definition: PDGUtils.cxx:160
const int kPdgAntiXi0
Definition: PDGCodes.h:79
bool IsParticle(int pdgc)
not ion or pseudo-particle
Definition: PDGUtils.cxx:45
const int kPdgXi0
Definition: PDGCodes.h:77
const int kPdgNuE
Definition: PDGCodes.h:28
bool IsNeutrino(int pdgc)
Definition: PDGUtils.cxx:108
THE MAIN GENIE PROJECT NAMESPACE
Definition: GeneratorBase.h:8
const int kPdgSDDiquarkS1
Definition: PDGCodes.h:60
const int kPdgLambda
Definition: PDGCodes.h:69
bool IsUQuark(int pdgc)
Definition: PDGUtils.cxx:249
const int kPdgBQuark
Definition: PDGCodes.h:50
const int kPdgAntiSigma0
Definition: PDGCodes.h:75
bool IsNucleon(int pdgc)
Definition: PDGUtils.cxx:309
const int kPdgClusterNP
Definition: PDGCodes.h:192
const int kPdgAntiNuE
Definition: PDGCodes.h:29
const int kPdgWM
Definition: PDGCodes.h:169
const int kPdgSUDiquarkS1
Definition: PDGCodes.h:62
const int kPdgDarkMatter
Definition: PDGCodes.h:195
const int kPdgUQuark
Definition: PDGCodes.h:42
const int kPdgNuMu
Definition: PDGCodes.h:30
int IonPdgCodeToA(int pdgc)
Definition: PDGUtils.cxx:61
const int kPdgSUDiquarkS0
Definition: PDGCodes.h:61
bool IsAntiNuTau(int pdgc)
Definition: PDGUtils.cxx:175
bool IsNuE(int pdgc)
Definition: PDGUtils.cxx:150
int SwitchProtonNeutron(int pdgc)
Definition: PDGUtils.cxx:319
bool IsAntiQuark(int pdgc)
Definition: PDGUtils.cxx:241
const int kPdgAntiMuon
Definition: PDGCodes.h:38
const int kPdgSSDiquarkS1
Definition: PDGCodes.h:63
bool IsDarkMatter(int pdgc)
Definition: PDGUtils.cxx:125
const int kPdgSigma0
Definition: PDGCodes.h:72
bool IsChargedLepton(int pdgc)
Definition: PDGUtils.cxx:99
bool IsSQuark(int pdgc)
Definition: PDGUtils.cxx:259
bool IsKaon(int pdgc)
Definition: PDGUtils.cxx:294
bool IsAntiSQuark(int pdgc)
Definition: PDGUtils.cxx:279
const int kPdgElectron
Definition: PDGCodes.h:35
bool IsAntiDQuark(int pdgc)
Definition: PDGUtils.cxx:274
const int kPdgZ0
Definition: PDGCodes.h:167
const int kPdgSQuark
Definition: PDGCodes.h:46
const int kPdgClusterNN
Definition: PDGCodes.h:191
const int kPdgK0
Definition: PDGCodes.h:151
int ModifyNucleonCluster(int pdgc, int dQ)
Definition: PDGUtils.cxx:327
Float_t Z
Definition: plot.C:38
const int kPdgSDDiquarkS0
Definition: PDGCodes.h:59
const int kPdgCQuark
Definition: PDGCodes.h:48
bool IsHadron(int pdgc)
Definition: PDGUtils.cxx:355
bool IsNeutron(int pdgc)
Definition: PDGUtils.cxx:304
bool IsPosChargedLepton(int pdgc)
Definition: PDGUtils.cxx:140
bool IsNuMu(int pdgc)
Definition: PDGUtils.cxx:155
const int kPdgAntiUQuark
Definition: PDGCodes.h:43
int GeantToPdg(int geant_code)
Definition: PDGUtils.cxx:374
bool IsProton(int pdgc)
Definition: PDGUtils.cxx:299
const int kPdgAntiOmegaP
Definition: PDGCodes.h:82
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE...
Definition: Messenger.h:97
const int kPdgTau
Definition: PDGCodes.h:39
static constexpr double L
const int kPdgUDDiquarkS1
Definition: PDGCodes.h:57
const int kPdgKM
Definition: PDGCodes.h:150
const int kPdgGamma
Definition: PDGCodes.h:166
bool IsAntiNeutrino(int pdgc)
Definition: PDGUtils.cxx:116
const int kPdgAntiDQuark
Definition: PDGCodes.h:45
bool IsDiQuark(int pdgc)
Definition: PDGUtils.cxx:223
const int kPdgIndep
Definition: PDGCodes.h:203
bool IsAntiMuon(int pdgc)
Definition: PDGUtils.cxx:195
const int kPdgKP
Definition: PDGCodes.h:149
bool IsTau(int pdgc)
Definition: PDGUtils.cxx:200
const int kPdgEta
Definition: PDGCodes.h:138
const int kPdgPiP
Definition: PDGCodes.h:135
const int kPdgPi0
Definition: PDGCodes.h:137
const int kPdgString
Definition: PDGCodes.h:202
const int kPdgDQuark
Definition: PDGCodes.h:44
const int kPdgTQuark
Definition: PDGCodes.h:52
bool IsPositron(int pdgc)
Definition: PDGUtils.cxx:185
bool IsMuon(int pdgc)
Definition: PDGUtils.cxx:190
const int kPdgK0L
Definition: PDGCodes.h:153
const int kPdgOmegaM
Definition: PDGCodes.h:81
const int kPdgAntiTQuark
Definition: PDGCodes.h:53
const int kPdgUDDiquarkS0
Definition: PDGCodes.h:56
const int kPdgAntiNuTau
Definition: PDGCodes.h:33
const int kPdgAntiNuMu
Definition: PDGCodes.h:31
bool IsAntiNuMu(int pdgc)
Definition: PDGUtils.cxx:170
#define pWARN
Definition: Messenger.h:61
const int kPdgSigmaM
Definition: PDGCodes.h:73
bool IsNeutralLepton(int pdgc)
Definition: PDGUtils.cxx:93
const int kPdgAntiSQuark
Definition: PDGCodes.h:47
const int kPdgDP
Definition: PDGCodes.h:158
const int kPdgAntiSigmaM
Definition: PDGCodes.h:76
bool Is2NucleonCluster(int pdgc)
Definition: PDGUtils.cxx:365
const int kPdgNuTau
Definition: PDGCodes.h:32
static const double A
Definition: Units.h:82
const int kPdgXiM
Definition: PDGCodes.h:78
bool IsIon(int pdgc)
Definition: PDGUtils.cxx:40
bool IsCQuark(int pdgc)
Definition: PDGUtils.cxx:264
const int kPdgAntiNeutron
Definition: PDGCodes.h:68
bool IsQuark(int pdgc)
Definition: PDGUtils.cxx:233
const int kPdgDMs
Definition: PDGCodes.h:163
bool IsAntiCQuark(int pdgc)
Definition: PDGUtils.cxx:284
bool IsPseudoParticle(int pdgc)
Definition: PDGUtils.cxx:25
bool IsNeutronOrProton(int pdgc)
Definition: PDGUtils.cxx:314
const int kPdgAntiCQuark
Definition: PDGCodes.h:49
bool IsDQuark(int pdgc)
Definition: PDGUtils.cxx:254
const int kPdgDM
Definition: PDGCodes.h:159
int IonPdgCode(int A, int Z)
Definition: PDGUtils.cxx:69
const int kPdgAntiBQuark
Definition: PDGCodes.h:51
const int kPdgAntiProton
Definition: PDGCodes.h:66
assert(nhit_max >=nhit_nbins)
int Neutrino2ChargedLepton(int pdgc)
Definition: PDGUtils.cxx:210
const int kPdgPiM
Definition: PDGCodes.h:136
const int kPdgAntiTau
Definition: PDGCodes.h:40
const int kPdgSigmaP
Definition: PDGCodes.h:71
bool IsBaryonResonance(int pdgc)
is input a baryon resonance?
const int kPdgAntiXiP
Definition: PDGCodes.h:80
int IonPdgCodeToZ(int pdgc)
Definition: PDGUtils.cxx:53
bool IsBaryonResonance(int pdgc)
Definition: PDGUtils.cxx:360
const int kPdgProton
Definition: PDGCodes.h:65
const int kPdgCluster
Definition: PDGCodes.h:201
const int kPdgAntiLambda
Definition: PDGCodes.h:70
const int kPdgMuon
Definition: PDGCodes.h:37
const int kPdgK0S
Definition: PDGCodes.h:154
const int kPdgAntiSigmaP
Definition: PDGCodes.h:74
const int kPdgPositron
Definition: PDGCodes.h:36
const int kPdgNeutron
Definition: PDGCodes.h:67
const int kPdgWP
Definition: PDGCodes.h:168
const int kPdgD0
Definition: PDGCodes.h:160
Most commonly used PDG codes. A set of utility functions to handle PDG codes is provided in PDGUtils...
bool IsAntiNuE(int pdgc)
Definition: PDGUtils.cxx:165
bool IsAntiTau(int pdgc)
Definition: PDGUtils.cxx:205
bool IsLepton(int pdgc)
Definition: PDGUtils.cxx:84
bool IsNegChargedLepton(int pdgc)
Definition: PDGUtils.cxx:131
bool IsElectron(int pdgc)
Definition: PDGUtils.cxx:180
bool IsAntiUQuark(int pdgc)
Definition: PDGUtils.cxx:269
const int kPdgDDDiquarkS1
Definition: PDGCodes.h:55
const int kPdgClusterPP
Definition: PDGCodes.h:193