StRoot  1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
StParticleTable.cc
1 /***************************************************************************
2  *
3  * $Id: StParticleTable.cc,v 1.31 2021/04/09 15:59:26 jwebb Exp $
4  *
5  * Author: Thomas Ullrich, May 99 (based on Geant4 code, see below)
6  ***************************************************************************
7  *
8  * The design of the StParticleDefinition class and all concrete
9  * classes derived from it is largely based on the design of the
10  * G4ParticleDefinition class from Geant4 (RD44).
11  * Although the code is in large parts different (modified or rewritten)
12  * and adapted to the STAR framework the basic idea stays the same.
13  *
14  ***************************************************************************
15  *
16  * $Log: StParticleTable.cc,v $
17  * Revision 1.31 2021/04/09 15:59:26 jwebb
18  * Add particle definitions to support H3lambda quasi two body decay
19  *
20  * Revision 1.30 2021/01/12 14:34:12 jwebb
21  * Update to gstar_part.g and StarClassLibrary to support simulation of
22  * H4 Lambda , He4 Lambda and He5 Lambda hypernuclei.
23  *
24  * Revision 1.29 2017/10/30 15:23:54 jwebb
25  * Add K*0(892) aka pdg 313 to gstar with g3id = 10013
26  *
27  * Revision 1.28 2016/11/28 21:52:43 jwebb
28  * Add psi(2s) --> mu+mu- with 100% branching ratio.
29  *
30  * Revision 1.27 2016/07/29 15:38:51 jwebb
31  * Fixed error in G3ID to PDGid mapping.
32  *
33  * Revision 1.26 2015/07/31 21:32:58 jwebb
34  * Attempt to propagate a PDG id for antideuteron.
35  *
36  * Revision 1.25 2015/06/23 14:53:36 jwebb
37  * StarClassLibrary support for H0 dibaryon.
38  *
39  * Revision 1.24 2015/06/08 16:24:34 jwebb
40  * Correct mapping between G3 id and pdg id. The G3 is the key and must be unique. THe pdg id is the value, and can repeat.
41  *
42  * Revision 1.23 2015/06/05 14:01:34 jwebb
43  * JPsi (id=168, dimuon channel) added to particle table
44  *
45  * Revision 1.22 2014/06/25 14:19:24 jwebb
46  * Added psi prime --> e+e-
47  *
48  * Revision 1.21 2014/01/29 16:21:43 jwebb
49  * Added D_star_plus (minus) --> D0 (bar) pi+ (-) 100% BR
50  *
51  * Revision 1.20 2013/04/18 20:05:29 jwebb
52  * Ticket #2574 Wrong Omega/Anti-Omega Geant ID.
53  *
54  * PDG +3334 id was incorrectly assigned to the Omega+... should be -3334 for
55  * Omega+ and +3334 for Omega-. IDs have been swapped.
56  *
57  * Revision 1.19 2013/03/14 18:27:26 jwebb
58  * Added pi0 --> e+e- gamma 100% gid=10007
59  * Added K0long --> nu e- pi+ 100% gid=10010
60  * Added K0long --> nu e+ pi- 100% gid=10110
61  *
62  * http://www.star.bnl.gov/rt2/Ticket/Display.html?id=2549
63  *
64  * Revision 1.18 2013/01/31 18:21:46 jwebb
65  * Updated StarClassLibrary and gstar_part.g to add the H Dibaryon.
66  *
67  * Revision 1.17 2012/06/25 16:02:05 jwebb
68  * Added Xi0(1530).
69  *
70  * Revision 1.16 2011/08/29 20:28:26 jwebb
71  * Added K+ --> e+ pi0 nu and K- --> e- pi0 nu to satisfy an emedding
72  * request http://drupal.star.bnl.gov/STAR/starsimrequests/2010/aug/31/ke3-pp-200-gev-run9
73  *
74  * Also added the other top 6 decay modes as 10011 -- 15011 and 10012 -- 15012.
75  *
76  * Revision 1.15 2011/08/12 15:32:54 jwebb
77  *
78  * Added anti-hypertriton. Mapped hyper-triton and anti-hyper-triton to
79  * geant IDs 6[12]053 and 6[12]054, with two decay modes:
80  *
81  * H3(lambda) --> He3 pi- 61053 antiparticle=61054
82  * H3(lambda) --> d p pi- 62053 antiparticle=62054
83  *
84  * Revision 1.14 2011/07/20 17:57:52 jwebb
85  *
86  * Updated StParticleTable to provide access to anti-nuclei via the "geant" ID.
87  *
88  * Revision 1.13 2011/03/30 17:32:50 jwebb
89  * Added anti-nuclei (deuteron, triton, alpha and helium3) to the table.
90  *
91  * Revision 1.12 2011/03/25 18:17:46 jwebb
92  * Updates to StParticleTable and additions to STAR Class Library
93  *
94  * (1) resolve ticket 2097
95  * (2) include all particles/deays defined in gstar_part.g
96  * (3) added few anti-nuclei in anticipation of future needs.
97  * (3) added the geantino for completeness
98  *
99  * Revision 1.11 2011/03/15 22:41:43 jwebb
100  * (1) Added Omega+/- and Xi+/- embedding definitions.
101  * (2) 1st attempt at improving the Doxygenization of the particle table.
102  *
103  * Revision 1.10 2010/08/03 13:51:31 jwebb
104  * LambdaBar(1520) provided in particle table with Geant ID=996.
105  *
106  * Revision 1.9 2010/05/07 15:37:11 jwebb
107  * Added StKaonZeroMode0809 to represent the k0 --> pi+ pi- w/ 100% br in
108  * gstar_part.g.
109  *
110  * Revision 1.8 2010/04/06 14:16:22 jwebb
111  * Redefined the geant ID of the lambda(1520) from 706 to 995, to make
112  * consistent with usage in embedding group.
113  *
114  * Revision 1.7 2010/03/22 21:32:34 jwebb
115  * And set the pdg ID to geant ID mapping.
116  *
117  * Revision 1.6 2010/01/28 21:54:20 jwebb
118  * Added the Sigma(1385) baryons.
119  *
120  * Revision 1.5 2010/01/28 20:05:20 jwebb
121  * Modifications to StParticleTable.cc (1) add the 'new' particle classes
122  * defined on 01/28/10 to the table and, (2) add the existing J/Psi and B
123  * mesons to the table. Also defined a preprocessor macro to make reading
124  * and modifying the code a bit easier.
125  *
126  * Revision 1.4 2000/04/06 22:25:38 ullrich
127  * Added phi and omega. More STAR specific Geant IDs.
128  *
129  * Revision 1.3 1999/12/21 15:14:23 ullrich
130  * Modified to cope with new compiler version on Sun (CC5.0).
131  *
132  * Revision 1.2 1999/09/24 01:23:52 fisyak
133  * Reduced Include Path
134  *
135  * Revision 1.1 1999/05/14 18:48:14 ullrich
136  * Initial Revision
137  *
138  **************************************************************************/
139 #include "StParticleTable.hh"
140 #include "StParticleDefinition.hh"
141 
142 #include "StarPDGEncoding.hh"
143 #define kUndefined _undefined_particle_id++
144 long _undefined_particle_id = 2000000000; /* Unique PDG ID for each undefined particle */
145 
146 #if defined (__SUNPRO_CC) && __SUNPRO_CC < 0x500
147 #include <ospace/stl/src/treeaux.cpp> // CC4.2 with ObjectSpace only
148 #endif
149 
150 #include "StAntiDeuteron.hh"
151 #include "StAntiTriton.hh"
152 #include "StAntiAlpha.hh"
153 #include "StAntiHelium3.hh"
154 #include "StAntiHyperTriton.hh"
155 #include "StHyperTriton.hh"
156 #include "StHDibaryon.hh"
157 #include "StHyperNuclei.hh"
158 
159 StParticleTable* StParticleTable::mParticleTable = 0;
160 
161 StParticleTable::~StParticleTable() {/* noop */}
162 
167 // lift into StarPDGEncoding
168 // Int_t hid( Int_t z, Int_t a, Int_t l=0 )
169 // {
170 // // 10LZZZAAAI
171 // return ( 1000000000
172 // + 10000000*l
173 // + 10000*z
174 // + 10*a );
175 // }
176 
177 
178 
179 StParticleTable::StParticleTable()
180 {
181  //
182  // Setup Geant3 -> PDG table
183  // Note, the STAR specific definitions
184  //
185  typedef mGeantPdgMapType::value_type geantPdgPairType;
186 
187  // Helper macro to map geant ID to PDG ID. A "DCAY" mode is also specificied, and doxygen comments
188  // added to the source code.
189 #define Geant2Pdg(X,Y, DCAY) { \
190  \
191  \
192  \
193  \
194  mGeantPdgMap.insert(geantPdgPairType(X,Y)); \
195  }
196 
197 
201  Geant2Pdg(1, 22, gamma);
202  Geant2Pdg(2, -11, e+); // e+
203  Geant2Pdg(3, 11, e-); // e-
204  Geant2Pdg(4, 12, neutrino); // neutrino (ambigious)
205  Geant2Pdg(5, -13, mu+); // mu+
206  Geant2Pdg(6, 13, mu-); // mu-
207  Geant2Pdg(7, 111, pi0); // pi0
208  Geant2Pdg(8, 211, pi+); // pi+
209  Geant2Pdg(9, -211, pi-); // pi-
210  Geant2Pdg(10, 130, K0_Long); // K0_long
211  Geant2Pdg(11, 321, Kaon+ ); // K+
212  Geant2Pdg(12, -321, Kaon- ); // K-
213  Geant2Pdg(13, 2112, neutron); // n
214  Geant2Pdg(14, 2212, proton); // p
215  Geant2Pdg(15, -2212, antiproton); // anti_p
216  Geant2Pdg(16, 310, K0_short); // K0_short
217  Geant2Pdg(17, 221, eta); // eta
218  Geant2Pdg(18, 3122, lambda); // lambda
219  Geant2Pdg(19, 3222, sigma+); // sigma+
220  Geant2Pdg(20, 3212, sigma0); // sigma0
221  Geant2Pdg(21, 3112, sigma-); // sigma-
222  Geant2Pdg(22, 3322, Xi0); // Xi0
223  Geant2Pdg(23, 3312, XiMinus); // Xi-
224  Geant2Pdg(24, 3334, Omega); // Omega
225  Geant2Pdg(25, -2112, AntiNeutron ); // anti_n
226  Geant2Pdg(26, -3122, AntiLambda ); // anti_lambda
227  Geant2Pdg(27, -3222, AntiSigma- ); // anti_sigma-
228  Geant2Pdg(28, -3212, AntiSigma0 ); // anti_sigma0
229  Geant2Pdg(29, -3112, AntiSigma+ ); // anti_sigma+
230  Geant2Pdg(30, -3322, AntiXi0 ); // anti_Xi0
231  Geant2Pdg(31, -3312, AntiXi+ ); // anti_Xi+
232  Geant2Pdg(32, -3334, AntiOmega+ ); // anti_omega+
233  Geant2Pdg(33, -15, AntiTau ); // anti_tau (STAR def.)
234  Geant2Pdg(34, 15, Tau); // tau (STAR def.)
235  Geant2Pdg(35, 411, D+ ); // D+ (STAR def.)
236  Geant2Pdg(36, -411, D- ); // D- (STAR def.)
237  Geant2Pdg(37, 421, D0); // D0 (STAR def.)
238  Geant2Pdg(38, -421, AntiD0 ); // anti_D0 (STAR def.)
239  Geant2Pdg(39, 431, Ds+ ); // Ds+ (STAR def.)
240  Geant2Pdg(40, -431, Ds- ); // Ds- (STAR def.)
241  Geant2Pdg(41, 4122, Lambda_c+ ); // lambda_c+ (STAR def.)
242  Geant2Pdg(42, 24, W+ ); // W+ (STAR def.)
243  Geant2Pdg(43, -24, W- ); // W- (STAR def.)
244  Geant2Pdg(44, 23, Z0 ); // Z0 (STAR def.)
245 
246  Geant2Pdg(45, hid(1,2) , Deuteron ); // The deuteron
247  Geant2Pdg(46, hid(1,3) , Triton ) ; // The triton
248  Geant2Pdg(47, hid(2,4) , Alpha ) ; // The alpha
249  Geant2Pdg(48, kUndefined, Geantino ); // The mythical geantino
250  Geant2Pdg(49, hid(2,3) , Helium3 ); // Helium3
251  Geant2Pdg(50, 22, Cerenkov ); // Cerenkov photons
252 
253  Geant2Pdg(54, -hid(2,3) , AntiHelium3 ); // AntiHelium3 );
254 
256 
257 
261  Geant2Pdg(52, kHyperTriton, HyperTriton ); // Star def. HyperTriton (fake pdg id)
263 
267  Geant2Pdg( 60, +413, DStar+ ); // D*+
268  Geant2Pdg( 61, -413, DStar- ); // D*-
269  Geant2Pdg( 62, +423, DStar0 ); // D*0
270  Geant2Pdg( 63, -423, DStar0Bar ); // D*0 bar
271 
272 
273 
274  Geant2Pdg(70, +521, B+); // B+ meson
275  Geant2Pdg(71, -521, B-); // B- meson
276  Geant2Pdg(72, +511, B0); // B0 meson
277  Geant2Pdg(73, -511, B0Bar ); // B0-bar meson
279 
280 
284  Geant2Pdg( 97, -3122, LambdaBar --> pbar + pi+ );
285  Geant2Pdg( 98, +3122, Lambda --> p + pi- );
287 
288  Geant2Pdg( 149, kDalitz, Pi0 --> e+ e- gamma ); // pi0 --> e+ e- gamma
289 
292  Geant2Pdg(150, 223, omega); // omega meson (STAR def.)
293  Geant2Pdg(151, 333, phi); // phi meson (STAR def.)
294  Geant2Pdg(152, 113, rho); // rho meson (STAR def.)
295  Geant2Pdg(153, 213, rho+); // rho+ meson (STAR def.)
296  Geant2Pdg(154, -213, rho-); // rho- meson (STAR def.)
297  Geant2Pdg(155, 311, K0); // K0 (STAR def.)
298  Geant2Pdg(156, -311, K0Bar); // anti_K0 (STAR def.)
300 
301 
302 
306 
307  Geant2Pdg( 160, 443, JPsi ); // JPsi
308  Geant2Pdg( 167, 100443, Psi2c ); // Psi' --> e+e-
309  Geant2Pdg( 169, 200443, Psi2c ); // Psi' --> mu+mu-
310 
311  Geant2Pdg( 161, 553, Upsilon1S); // Upsilon(1S)
312  Geant2Pdg( 162, 100553, Upsilon2S); // Upsilon(2S)
313  Geant2Pdg( 163, 200553, Upsilon3S); // Uspilon(3S)
315 
319  Geant2Pdg( 164, 553, Upsilon1S); // Upsilon(1S) -- mu+ mu- channel w/ incorrect partial width
320  Geant2Pdg( 165, 100553, Upsilon2S); // Upsilon(2S) -- mu+ mu- channel w/ incorrect partial width
321  Geant2Pdg( 166, 200553, Upsilon3S); // Uspilon(3S) -- mu+ mu- channel w/ incorrect partial width
322 
323  Geant2Pdg( 168, 443, JPsi); // JPsi -- mu+ mu- channel w/ incorrect partial widths
325 
328  Geant2Pdg( 701, +3224, Sigma(1385)+ ); // Sigma 1385 +
329  Geant2Pdg( 702, +3114, Sigma(1385)- ); // Sigma 1385 -
330  Geant2Pdg( 703, -3114, SigmaBar(1385)+ ); // Sigma 1385 plus bar
331  Geant2Pdg( 704, -3224, SigmaBar(1385)- ); // Sigma 1385 minus bar
332  Geant2Pdg( 707, 100311, K0-->pi+pi- ); // K0 --> pi+ pi-
334 
335 
336  Geant2Pdg( +995, +20003122, Lambda(1520) ); // Lambda 1520
337  Geant2Pdg( +996, -20003122, LamdaBar(1520) ); // Lambda 1520
338 
342 
343  Geant2Pdg( 10007, 111, pi0 --> e+ e- gamma );
344 
345  Geant2Pdg( 10010, 130, K0 Long --> nu e- pi+ );
346  Geant2Pdg( 10110, 130, K0 Long --> nu e+ pi- );
347 
348  Geant2Pdg(10017, 221, eta --> e+ e- gamma);
349  Geant2Pdg(10018, 3122, lambda --> p + pi- );
350  Geant2Pdg(10026,-3122, lambdaBar --> pbar + pi+ );
351  Geant2Pdg(10039, 431, D_s_+ --> phi + pi+ w/ phi --> K+ K- );
352  Geant2Pdg(10040, -431, D_s_- --> phi + pi- w/ phi --> K+ K- );
353  Geant2Pdg(10150, 223, omega --> e+ e- );
354  Geant2Pdg(10151, 333, phi --> K+ K- );
355  Geant2Pdg(11151, 333, phi --> e+ e- );
356 
357  Geant2Pdg(10011, 321, Kaon+ --> mu+ nu ); // K+
358  Geant2Pdg(10012, -321, Kaon- --> mu- nu ); // K-
359 
360  Geant2Pdg(11011, 321, Kaon+ --> pi+ pi0 ); // K+
361  Geant2Pdg(11012, -321, Kaon- --> pi- pi0 ); // K-
362 
363  Geant2Pdg(12011, 321, Kaon+ --> 2 pi+ pi- ); // K+
364  Geant2Pdg(12012, -321, Kaon- --> 2 pi- pi+ ); // K-
365 
366  Geant2Pdg(13011, 321, Kaon+ --> e+ nu pi0 ); // K+
367  Geant2Pdg(13012, -321, Kaon- --> e- nu pi0 ); // K-
368 
369  Geant2Pdg(14011, 321, Kaon+ --> mu+ nu pi0 ); // K+
370  Geant2Pdg(14012, -321, Kaon- --> mu- nu pi0 ); // K-
371 
372  Geant2Pdg(15011, 321, Kaon+ --> pi+ pi0 pi0 ); // K+
373  Geant2Pdg(15012, -321, Kaon- --> pi- pi0 pi0 ); // K-
374 
375  Geant2Pdg(10013, 313, Kstar0 --> K+ pi- );
376 
377 
378  Geant2Pdg( 10060, +413, DStar+ ); // D*+
379  Geant2Pdg( 10061, -413, DStar- ); // D*-
380  Geant2Pdg( 10062, +423, DStar0 ); // D*0
381  Geant2Pdg( 10063, -423, DStar0Bar ); // D*0 bar
382 
383 
384  Geant2Pdg( 40001, -3334, Omega+);
385  Geant2Pdg( 40002, 3334, Omega-);
386  Geant2Pdg( 40003, +3312, XiMinus );
387  Geant2Pdg( 40004, -3312, XiPlus );
388  Geant2Pdg( 40005, +3322, XiZero );
389  Geant2Pdg( 40006, +3322, XiZeroBar );
390 
391  Geant2Pdg( 40007, +3324, XiZero 1530 );
392  Geant2Pdg( 40008, -3324, XiZero 1530 bar );
393 
395 
399  Geant2Pdg( 50045, -hid(1,2) , anti-deuteron );
400  Geant2Pdg( 50046, -hid(1,3) , anti-triton );
401  Geant2Pdg( 50047, -hid(2,4) , anti-alpha );
402  Geant2Pdg( 50048, -hid(2,3) , anti-He3 );
404 
408  Geant2Pdg( 61053, kHyperTriton, H3(Lambda) --> He3 piminus );
409  Geant2Pdg( 61054, kAntiHyperTriton, AntiH3(Lambda) --> AntiHe3 piplus );
410  Geant2Pdg( 62053, kHyperTriton, H3(Lambda) --> d p piminus );
411  Geant2Pdg( 62054, kAntiHyperTriton, AntiH3(Lambda) --> dbar pbar piplus );
412  Geant2Pdg( 63053, kHyperTriton, H3(Lambda) --> quasi 2 body);
413  Geant2Pdg( 63054, kAntiHyperTriton, AntiH3(Lambda) --> quasi 2 body);
414 
415  Geant2Pdg( 61055, hid(1,3,1), H4(Lambda) --> He4 piminus );
416  Geant2Pdg( 61057, hid(2,3,1), He4(Lambda) --> He3 proton piminus );
417  Geant2Pdg( 61059, hid(2,4,1), He5(Lambda) --> He4 proton piminus );
418 
419  Geant2Pdg( 61056, -hid(1,3,1), H4(Lambda)Bar --> He4Bar piplus );
420 
421 
423 
427  Geant2Pdg( 60001, kUndefined, H-Dibaryon --> Lambda + piminus + proton );
428 
429  Geant2Pdg( 60801, 801, H0-strangelet --> proton + Sigma- );
430 
432 
433 
434 #undef Geant2Pdg
435 
436 }
437 
438 StParticleTable::StParticleTable(const StParticleTable &) {/* private */}
439 
440 StParticleTable* StParticleTable::instance()
441 {
442  return particleTable();
443 }
444 
445 StParticleTable* StParticleTable::particleTable()
446 {
447  if (!mParticleTable) mParticleTable = new StParticleTable;
448  return mParticleTable;
449 }
450 
451 unsigned int StParticleTable::entries() const {return mNameMap.size();}
452 
453 unsigned int StParticleTable::size() const {return mNameMap.size();}
454 
455 bool StParticleTable::contains(const string& name) const
456 {
457  return (findParticle(name) != 0);
458 }
459 
460 bool StParticleTable::contains(int pdgId) const
461 {
462  return (findParticle(pdgId) != 0);
463 }
464 
465 bool StParticleTable::containsGeantId(int geantId) const
466 {
467  return (findParticleByGeantId(geantId) != 0);
468 }
469 
470 StParticleDefinition* StParticleTable::findParticle(const string& name) const
471 {
472  mNameMapType::const_iterator i = mNameMap.find(name);
473  if (i == mNameMap.end())
474  return 0;
475  else
476  return (*i).second;
477 }
478 
479 StParticleDefinition* StParticleTable::findParticle(int pdgId) const
480 {
481  mPdgMapType::const_iterator p = mPdgMap.find(pdgId);
482  if (p == mPdgMap.end())
483  return 0;
484  else
485  return (*p).second;
486 }
487 
488 StParticleDefinition* StParticleTable::findParticleByGeantId(int geantId) const
489 {
490  //
491  // Two ways to find the particle:
492  // 1. If it's an elementary particle its in the PDG list
493  // 2. If it is a nucleus/ion find it via the name list
494  //
495 
496  StParticleDefinition *p = 0;
497  switch (geantId) {
498  case 45:
499  p = findParticle(string("deuteron"));
500  break;
501  case 46:
502  p = findParticle(string("triton"));
503  break;
504  case 47:
505  p = findParticle(string("alpha"));
506  break;
507  case 49:
508  p = findParticle(string("He3"));
509  break;
510  case 50:
511  p = findParticle(string("opticalphoton"));
512  break;
513  case 50045:
514  p = StAntiDeuteron::instance();
515  break;
516  case 50046:
517  p = StAntiTriton::instance();
518  break;
519  case 50047:
520  p = StAntiAlpha::instance();
521  break;
522 
523  case 50049:
524  case 54:
525  p = StAntiHelium3::instance();
526  break;
527 
528  case 60053:
529  case 61053:
530  case 62053:
531  case 63053:
532  p = StHyperTriton::instance();
533  break;
534  case 60054:
535  case 61054:
536  case 62054:
537  case 63054:
538  p = StAntiHyperTriton::instance();
539  break;
540 
541 
542  case 60001:
543  p = StHDibaryon::instance();
544  break;
545 
546 
547 
548 
549  default:
550  mGeantPdgMapType::const_iterator i = mGeantPdgMap.find(geantId);
551  if (i != mGeantPdgMap.end())
552  p = findParticle((*i).second);
553  break;
554  }
555  return p;
556 }
557 
558 void StParticleTable::insert(StParticleDefinition* p)
559 {
560  typedef mPdgMapType::value_type pdgPairType;
561  typedef mNameMapType::value_type namePairType;
562 
563  if (p->pdgEncoding() != 0)
564  mPdgMap.insert(pdgPairType(p->pdgEncoding(), p));
565  mNameMap.insert(namePairType(p->name(), p));
566 }
567 
568 void StParticleTable::erase(StParticleDefinition* p)
569 {
570  mPdgMapType::iterator i = mPdgMap.find(p->pdgEncoding());
571  if (i != mPdgMap.end()) mPdgMap.erase(i);
572 
573  mNameMapType::iterator j = mNameMap.find(p->name());
574  if (j != mNameMap.end()) mNameMap.erase(j);
575 }
576 
577 void StParticleTable::dump(ostream& os)
578 {
579  mNameMapType::iterator i;
580  for (i = mNameMap.begin(); i != mNameMap.end(); ++i)
581  cout << *((*i).second) << endl;
582 }
583 
584 
585 StVecPtrParticleDefinition
586 StParticleTable::allParticles() const
587 {
588  StVecPtrParticleDefinition vec;
589  mNameMapType::const_iterator i;
590  for (i = mNameMap.begin(); i != mNameMap.end(); ++i)
591  vec.push_back((*i).second);
592  return vec;
593 }
594 
595 
596 
597 
Generated by   doxygen 1.8.5