1 package org.lcsim.event.base;
2
3 import static java.lang.Math.abs;
4
5 /**
6 *
7 * This class provides static utility methods for determining the type of a particle based on the PDGID. It based
8 * on the primary document on PDGIDs issued by the Particle Data Group and also on some code from the ATLAS LXR.
9 *
10 * <h2>References</h2>
11 * <ul>
12 * <li><a href="http://pdg.lbl.gov/2007/mcdata/mc_particle_id_contents.html">PDG Numbering Scheme</a></li>
13 * <li><a href="http://alxr.usatlas.bnl.gov/lxr/source/atlas/PhysicsAnalysis/MuonID/MuonIDValidation/MuonIDValidation/pdg.h">pdg.h</a></li>
14 * <li><a href="http://alxr.usatlas.bnl.gov/lxr/source/atlas/PhysicsAnalysis/MuonID/MuonIDValidation/src/pdg.cxx">pdg.cxx</a></li>
15 * </ul>
16 *
17 * @author Jeremy McCormick <jeremym@slac.stanford.edu>
18 * @version $Id: ParticleTypeClassifier.java,v 1.3 2011/08/24 18:51:17 jeremy Exp $
19 *
20 */
21 public final class ParticleTypeClassifier
22 {
23 /**
24 * Class is 100% static utility methods
25 * so it should not be instantiated.
26 */
27 private ParticleTypeClassifier()
28 {}
29
30 /**
31 * True if <code>p</code> is a lepton.
32 * Checks that <code>p</code> is between 11 and 18.
33 * @param p The PDGID.
34 * @return True if <code>p</code> is a lepton.
35 */
36 public static boolean isLepton(int p)
37 {
38 return p > 10 && p < 19;
39 }
40
41 /**
42 * True if <code>p</code> is a charged lepton.
43 * @param p The PDGID.
44 * @return True if <code>p</code> is a charged lepton.
45 */
46 public static boolean isChargedLepton(int p)
47 {
48 int pp = abs(p);
49 return pp == 11 || pp == 13 || pp == 15 || pp == 17;
50 }
51
52 /**
53 * True if <code>p</code> is a neutrino.
54 * Checks that <code>p</code> is odd.
55 * @param p
56 * @return
57 */
58 public static boolean isNeutrino(int p)
59 {
60 int pp = abs(p);
61 return pp == 12 || pp == 14 || pp == 16 || pp == 18;
62 }
63
64 /**
65 * True if <code>p</code> is an electron.
66 * @param p
67 * @return
68 */
69 public static boolean isElectron(int p)
70 {
71 return p == 11;
72 }
73
74 /**
75 * True if <code>p</code> is a positron.
76 * @param p The PDGID.
77 * @return True if <code>p</code> is a postitron.
78 */
79 public static boolean isPositron(int p)
80 {
81 return p == -11;
82 }
83
84 /**
85 * True if <code>p</code> is a muon.
86 * @param p The PDGID.
87 * @return True if <code>p</code> is a muon.
88 */
89 public static boolean isMuon(int p)
90 {
91 return abs(p) == 13;
92 }
93
94 /**
95 * True if <code>p</code> is a tau.
96 * @param p The PDGID.
97 * @return True if <code>p</code> is a tau.
98 */
99 public static boolean isTau(int p)
100 {
101 return abs(p) == 15;
102 }
103
104 /**
105 * True if <code>p</code> is a photon.
106 * @param p The PDGID.
107 * @return True if <code>p</code> is a photon.
108 */
109 public static boolean isPhoton(int p)
110 {
111 return p == 22;
112 }
113
114 /**
115 * True if <code>p</code> is an electron or photon.
116 * @param p The PDGID.
117 * @return True if <code>p</code> is an electron or photon.
118 */
119 public static boolean isEM(int p)
120 {
121 return isElectron(p) || isPhoton(p);
122 }
123
124 /**
125 * True if <code>p</code> is a boson.
126 * @param p The PDGID.
127 * @return True if <code>p</code> is a boson.
128 */
129 public static boolean isBoson(int p)
130 {
131 int pp = abs(p);
132 return pp > 20 && pp < 38;
133 }
134
135 /**
136 * True if <code>p</code> is a quark.
137 * @param p
138 * @return
139 */
140 public static boolean isQuark(int p)
141 {
142 int pp = abs(p);
143 return pp > 0 && pp < 9;
144 }
145
146 /**
147 * True if <code>p</code> is a hadron.
148 * @param p The PDGID.
149 * @return True if <code>p</code> is a hadron.
150 * FIXME: This may be incorrect. Needs to be checked.
151 */
152 public static boolean isHadron(int p)
153 {
154 int pp = abs(p);
155 return pp > 100 && (pp < 1000000 || pp > 9000000) && (pp % 10 != 0);
156 }
157
158 /**
159 * True if <code>p</code> is a proton.
160 * @param p The PDGID.
161 * @return True if <code>p</code> is a proton.
162 */
163 public static boolean isProton(int p)
164 {
165 return p == 2212;
166 }
167
168 /**
169 * True if <code>p</code> is an antiproton.
170 * @param p The PDGID.
171 * @return True if <code>p</code> is a antiproton.
172 */
173 public static boolean isAntiProton(int p)
174 {
175 return p == -2212;
176 }
177
178 /**
179 * True if <code>p</code> is a neutron.
180 * @param p The PDGID.
181 * @return True if <code>p</code> is a neutron.
182 */
183 public static boolean isNeutron(int p)
184 {
185 return p == 2112;
186 }
187
188 /**
189 * True if <code>p</code> is an antineutron.
190 * @param p The PDGID.
191 * @return True if <code>p</code> is an antineutron.
192 */
193 public static boolean isAntiNeutron(int p)
194 {
195 return p == -2112;
196 }
197
198 /**
199 * True if <code>p</code> is a kaon.
200 * @param p The PDGID.
201 * @return True if <code>p</code> is an antineutron.
202 */
203 public static boolean isKaon(int p)
204 {
205 return p == 130 || p == 310 || p == 311 || abs(p) == 321;
206 }
207
208 /**
209 * True if <code>p</code> is a charged kaon.
210 * @param p The PDGID.
211 * @return True if particle is a charged kaon.
212 */
213 public static boolean isChargedKaon(int p)
214 {
215 return abs(p) == 321;
216 }
217
218 /**
219 * True if <code>p</code> is an UD hadron.
220 * @param p The PDGID.
221 * @return True if <code>p</code> is an UD hadron.
222 */
223 public static boolean isUDHadron(int p)
224 {
225 int flavor = flavor(p);
226 return isHadron(p) && (flavor == 1 || flavor == 2);
227 }
228
229 /**
230 * True if <code>p</code> is an S hadron.
231 * @param p The PDGID.
232 * @return True if <code>p</code> is an S hadron.
233 */
234 public static boolean isSHadron(int p)
235 {
236 return isHadron(p) && flavor(p) == 3;
237 }
238
239 /**
240 * True if <code>p</code> is a C hadron.
241 * @param p The PDGID.
242 * @return True if <code>p</code> is a C hadron.
243 */
244 public static boolean isCHadron(int p)
245 {
246 return isHadron(p) && flavor(p) == 4;
247 }
248
249 /**
250 * True if <code>p</code> is a B hadron.
251 * @param p The PDGID.
252 * @return True if <code>p</code> is a B hadron.
253 */
254 public static boolean isBHadron(int p)
255 {
256 return isHadron(p) && flavor(p) == 5;
257 }
258
259 /**
260 * True if <code>p</code> is a down quark.
261 * @param p The PDGID.
262 * @return True if <code>p</code> is a down quark.
263 */
264 public static boolean isDownQuark(int p)
265 {
266 return abs(p) == 1;
267 }
268
269 /**
270 * True if <code>p</code> is an up quark.
271 * @param p The PDGID.
272 * @return True if <code>p</code> is a up quark.
273 */
274 public static boolean isUpQuark(int p)
275 {
276 return abs(p) == 2;
277 }
278
279 /**
280 * True if <code>p</code> is a strange quark.
281 * @param p The PDGID.
282 * @return True if <code>p</code> is a strange quark.
283 */
284 public static boolean isStrangeQuark(int p)
285 {
286 return abs(p) == 3;
287 }
288
289 /**
290 * True if <code>p</code> is a charm quark.
291 * @param p The PDGID.
292 * @return True if <code>p</code> is a charm quark.
293 */
294 public static boolean isCharmQuark(int p)
295 {
296 return abs(p) == 4;
297 }
298
299 /**
300 * True if <code>p</code> is a bottom quark.
301 * @param p The PDGID.
302 * @return True if <code>p</code> is a bottom quark.
303 */
304 public static boolean isBottomQuark(int p)
305 {
306 return abs(p) == 5;
307 }
308
309 /**
310 * True if <code>p</code> is a top quark.
311 * @param p The PDGID.
312 * @return True if <code>p</code> is a top quark.
313 */
314 public static boolean isTopQuark(int p)
315 {
316 return abs(p) == 6;
317 }
318
319 /**
320 * True if particle is a K0L or a K0S.
321 * @param p
322 * @return
323 */
324 public static boolean isNeutralKaon(int p)
325 {
326 return p == 130 || p == 310;
327 }
328
329 /**
330 * True if <code>p</code> is an ion or nucleus.
331 * @param p The PDGID.
332 * @return True if <code>p</code> is an ion or nucleus.
333 * FIXME: This relies on the PDGID of ions and nuclei being 0, which may
334 * not be completely accurate. For instance, geantinos have a PDGID
335 * of 0 also, so it may not be correct for all cases.
336 */
337 public static boolean isIon(int p)
338 {
339 return p == 0;
340 }
341
342 /**
343 * True if <code>p</code> is a Z boson.
344 * @param p The PDGID.
345 * @return True if <code>p</code> is a Z boson.
346 */
347 public static boolean isZBoson(int p)
348 {
349 return p == 23;
350 }
351
352 /**
353 * True if <code>p</code> is a W boson.
354 * @param p The PDGID.
355 * @return True if <code>p</code> is a W boson.
356 */
357 public static boolean isWBoson(int p)
358 {
359 return abs(p) == 24;
360 }
361
362 /**
363 * True if <code>p</code> is any type of Higgs boson.
364 * @param p The PDGID.
365 * @return True if <code>p</code> is a Higgs boson.
366 */
367 public static boolean isHiggs(int p)
368 {
369 int pp = abs(p);
370 return pp == 25 || pp == 35 || pp == 36 || pp == 37;
371 }
372
373 /**
374 * True if <code>p</code> is a SUSY particle.
375 * @param p The PDGID.
376 * @return True if <code>p</code> is a SUSY particle.
377 */
378 public static boolean isSUSY(int p)
379 {
380 return p > 1000000 && p < 2000015;
381 }
382
383 /**
384 * True if <code>p</code> is a Technicolor particle.
385 * @param p The PDGID.
386 * @return True if <code>p</code> is a Technicolor particle.
387 */
388 public static boolean isTechnicolor(int p)
389 {
390 int pp = abs(p);
391 return pp > 3000110 && pp < 3000224;
392 }
393
394 /**
395 * Get the flavor of a hadron indicating its quark content.
396 * This method is only used internally.
397 * @param p The PDGID.
398 * @return The flavor of the particle.
399 */
400 static int flavor(int p)
401 {
402 int rid = abs(p) % 10000;
403 int flavor = 0;
404 if (rid > 999)
405 {
406 flavor = rid / 1000;
407 }
408 else
409 {
410 int flavor1 = rid / 100;
411 int flavor2 = (rid % 100) / 10;
412 flavor = flavor1;
413 if (flavor1 == flavor2 && flavor1 < 4)
414 {
415 flavor = 1;
416 }
417 if (p == 130) flavor = 3;
418 }
419 return flavor;
420 }
421 }