Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TDatabasePDG.cxx
Go to the documentation of this file.
1 // @(#)root/eg:$Id$
2 // Author: Pasha Murat 12/02/99
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #include "RConfigure.h"
13 #include "TROOT.h"
14 #include "TEnv.h"
15 #include "THashList.h"
16 #include "TExMap.h"
17 #include "TSystem.h"
18 #include "TDatabasePDG.h"
19 #include "TDecayChannel.h"
20 #include "TParticlePDG.h"
21 #include <stdlib.h>
22 
23 
24 /** \class TDatabasePDG
25  \ingroup eg
26 
27 Particle database manager class
28 
29 This manager creates a list of particles which by default is
30 initialised from with the constants used by PYTHIA6 (plus some
31 other particles added). See definition and the format of the default
32 particle list in $ROOTSYS/etc/pdg_table.txt
33 
34 There are 2 ways of redefining the name of the file containing the
35 particle properties
36 
37 -# One can define the name in .rootrc file:
38 
39 Root.DatabasePDG: $(HOME)/my_pdg_table.txt
40 
41 -# One can use TDatabasePDG::ReadPDGTable method explicitly:
42 
43  - TDatabasePDG *pdg = new TDatabasePDG();
44  - pdg->ReadPDGtable(filename)
45 
46 See TParticlePDG for the description of a static particle properties.
47 See TParticle for the description of a dynamic particle particle.
48 
49 <br>The current default pdg_table file displays lifetime 0 for some unstable particles.</br>
50 
51 */
52 
53 ClassImp(TDatabasePDG);
54 
55 ////////////////////////////////////////////////////////////////////////////////
56 /// Static function holding the instance.
57 
58 TDatabasePDG** GetInstancePtr()
59 {
60  static TDatabasePDG* fgInstance = nullptr;
61  return &fgInstance;
62 }
63 
64 ////////////////////////////////////////////////////////////////////////////////
65 /// Create PDG database. Initialization of the DB has to be done via explicit
66 /// call to ReadDataBasePDG (also done by GetParticle methods)
67 
68 TDatabasePDG::TDatabasePDG(): TNamed("PDGDB","The PDG particle data base")
69 {
70  fParticleList = 0;
71  fPdgMap = 0;
72  fListOfClasses = 0;
73  auto fgInstance = GetInstancePtr();
74  if (*fgInstance != nullptr) {
75  Warning("TDatabasePDG", "object already instantiated");
76  } else {
77  *fgInstance = this;
78  gROOT->GetListOfSpecials()->Add(this);
79  }
80 }
81 
82 ////////////////////////////////////////////////////////////////////////////////
83 /// Cleanup the PDG database.
84 
85 TDatabasePDG::~TDatabasePDG()
86 {
87  if (fParticleList) {
88  fParticleList->Delete();
89  delete fParticleList; // this deletes all objects in the list
90  if (fPdgMap) delete fPdgMap;
91  }
92  // classes do not own particles...
93  if (fListOfClasses) {
94  fListOfClasses->Delete();
95  delete fListOfClasses;
96  }
97  if (gROOT && !gROOT->TestBit(TObject::kInvalidObject))
98  gROOT->GetListOfSpecials()->Remove(this);
99  auto fgInstance = GetInstancePtr();
100  *fgInstance = nullptr;
101 }
102 
103 ////////////////////////////////////////////////////////////////////////////////
104 ///static function
105 
106 TDatabasePDG* TDatabasePDG::Instance()
107 {
108  auto fgInstance = GetInstancePtr();
109  if (*fgInstance == nullptr) {
110  // Constructor creates a new instance, inits fgInstance.
111  new TDatabasePDG();
112  }
113  return *fgInstance;
114 }
115 
116 ////////////////////////////////////////////////////////////////////////////////
117 /// Build fPdgMap mapping pdg-code to particle.
118 ///
119 /// Initial size is set so as to be able to hold at least 600
120 /// particles: 521 in default table, ALICE adds 54 more.
121 /// To be revisited after LHC discovers SUSY.
122 
123 void TDatabasePDG::BuildPdgMap() const
124 {
125  fPdgMap = new TExMap(4*TMath::Max(600, fParticleList->GetEntries())/3 + 3);
126  TIter next(fParticleList);
127  TParticlePDG *p;
128  while ((p = (TParticlePDG*)next())) {
129  fPdgMap->Add((Long_t)p->PdgCode(), (Long_t)p);
130  }
131 }
132 
133 ////////////////////////////////////////////////////////////////////////////////
134 ///
135 /// Particle definition normal constructor. If the particle is set to be
136 /// stable, the decay width parameter does have no meaning and can be set to
137 /// any value. The parameters granularity, LowerCutOff and HighCutOff are
138 /// used for the construction of the mean free path look up tables. The
139 /// granularity will be the number of logwise energy points for which the
140 /// mean free path will be calculated.
141 ///
142 
143 TParticlePDG* TDatabasePDG::AddParticle(const char *name, const char *title,
144  Double_t mass, Bool_t stable,
145  Double_t width, Double_t charge,
146  const char* ParticleClass,
147  Int_t PDGcode,
148  Int_t Anti,
149  Int_t TrackingCode)
150 {
151  TParticlePDG* old = GetParticle(PDGcode);
152 
153  if (old) {
154  printf(" *** TDatabasePDG::AddParticle: particle with PDGcode=%d already defined\n",PDGcode);
155  return 0;
156  }
157 
158  TParticlePDG* p = new TParticlePDG(name, title, mass, stable, width,
159  charge, ParticleClass, PDGcode, Anti,
160  TrackingCode);
161  fParticleList->Add(p);
162  if (fPdgMap)
163  fPdgMap->Add((Long_t)PDGcode, (Long_t)p);
164 
165  TParticleClassPDG* pclass = GetParticleClass(ParticleClass);
166 
167  if (!pclass) {
168  pclass = new TParticleClassPDG(ParticleClass);
169  fListOfClasses->Add(pclass);
170  }
171 
172  pclass->AddParticle(p);
173 
174  return p;
175 }
176 
177 ////////////////////////////////////////////////////////////////////////////////
178 /// assuming particle has already been defined
179 
180 TParticlePDG* TDatabasePDG::AddAntiParticle(const char* Name, Int_t PdgCode)
181 {
182  TParticlePDG* old = GetParticle(PdgCode);
183 
184  if (old) {
185  printf(" *** TDatabasePDG::AddAntiParticle: can't redefine parameters\n");
186  return NULL;
187  }
188 
189  Int_t pdg_code = abs(PdgCode);
190  TParticlePDG* p = GetParticle(pdg_code);
191 
192  if (!p) {
193  printf(" *** TDatabasePDG::AddAntiParticle: particle with pdg code %d not known\n", pdg_code);
194  return NULL;
195  }
196 
197  TParticlePDG* ap = AddParticle(Name,
198  Name,
199  p->Mass(),
200  1,
201  p->Width(),
202  -p->Charge(),
203  p->ParticleClass(),
204  PdgCode,
205  1,
206  p->TrackingCode());
207  return ap;
208 }
209 
210 
211 ////////////////////////////////////////////////////////////////////////////////
212 ///
213 /// Get a pointer to the particle object according to the name given
214 ///
215 
216 TParticlePDG *TDatabasePDG::GetParticle(const char *name) const
217 {
218  if (fParticleList == 0) ((TDatabasePDG*)this)->ReadPDGTable();
219 
220  TParticlePDG *def = (TParticlePDG *)fParticleList->FindObject(name);
221 // if (!def) {
222 // Error("GetParticle","No match for %s exists!",name);
223 // }
224  return def;
225 }
226 
227 ////////////////////////////////////////////////////////////////////////////////
228 ///
229 /// Get a pointer to the particle object according to the MC code number
230 ///
231 
232 TParticlePDG *TDatabasePDG::GetParticle(Int_t PDGcode) const
233 {
234  if (fParticleList == 0) ((TDatabasePDG*)this)->ReadPDGTable();
235  if (fPdgMap == 0) BuildPdgMap();
236 
237  return (TParticlePDG*) (Long_t)fPdgMap->GetValue((Long_t)PDGcode);
238 }
239 
240 ////////////////////////////////////////////////////////////////////////////////
241 /// Print contents of PDG database.
242 
243 void TDatabasePDG::Print(Option_t *option) const
244 {
245  if (fParticleList == 0) ((TDatabasePDG*)this)->ReadPDGTable();
246 
247  TIter next(fParticleList);
248  TParticlePDG *p;
249  while ((p = (TParticlePDG *)next())) {
250  p->Print(option);
251  }
252 }
253 
254 ////////////////////////////////////////////////////////////////////////////////
255 /// Converts Geant3 particle codes to PDG convention. (Geant4 uses
256 /// PDG convention already)
257 /// Source: BaBar User Guide, Neil I. Geddes,
258 ///
259 /// see <A href="http://www.slac.stanford.edu/BFROOT/www/Computing/Environment/NewUser/htmlbug/node51.html"> Conversion table</A>
260 ///
261 /// with some fixes by PB, marked with (PB) below. Checked against
262 /// PDG listings from 2000.
263 ///
264 /// Paul Balm, Nov 19, 2001
265 
266 Int_t TDatabasePDG::ConvertGeant3ToPdg(Int_t Geant3number) const
267 {
268 
269 
270  switch(Geant3number) {
271 
272  case 1 : return 22; // photon
273  case 25 : return -2112; // anti-neutron
274  case 2 : return -11; // e+
275  case 26 : return -3122; // anti-Lambda
276  case 3 : return 11; // e-
277  case 27 : return -3222; // Sigma-
278  case 4 : return 12; // e-neutrino (NB: flavour undefined by Geant)
279  case 28 : return -3212; // Sigma0
280  case 5 : return -13; // mu+
281  case 29 : return -3112; // Sigma+ (PB)*/
282  case 6 : return 13; // mu-
283  case 30 : return -3322; // Xi0
284  case 7 : return 111; // pi0
285  case 31 : return -3312; // Xi+
286  case 8 : return 211; // pi+
287  case 32 : return -3334; // Omega+ (PB)
288  case 9 : return -211; // pi-
289  case 33 : return -15; // tau+
290  case 10 : return 130; // K long
291  case 34 : return 15; // tau-
292  case 11 : return 321; // K+
293  case 35 : return 411; // D+
294  case 12 : return -321; // K-
295  case 36 : return -411; // D-
296  case 13 : return 2112; // n
297  case 37 : return 421; // D0
298  case 14 : return 2212; // p
299  case 38 : return -421; // D0
300  case 15 : return -2212; // anti-proton
301  case 39 : return 431; // Ds+
302  case 16 : return 310; // K short
303  case 40 : return -431; // anti Ds-
304  case 17 : return 221; // eta
305  case 41 : return 4122; // Lamba_c+
306  case 18 : return 3122; // Lambda
307  case 42 : return 24; // W+
308  case 19 : return 3222; // Sigma+
309  case 43 : return -24; // W-
310  case 20 : return 3212; // Sigma0
311  case 44 : return 23; // Z
312  case 21 : return 3112; // Sigma-
313  case 45 : return 0; // deuteron
314  case 22 : return 3322; // Xi0
315  case 46 : return 0; // triton
316  case 23 : return 3312; // Xi-
317  case 47 : return 0; // alpha
318  case 24 : return 3334; // Omega- (PB)
319  case 48 : return 0; // G nu ? PDG ID 0 is undefined
320 
321  default : return 0;
322 
323  }
324 }
325 
326 ////////////////////////////////////////////////////////////////////////////////
327 /// Converts pdg code to geant3 id
328 
329 Int_t TDatabasePDG::ConvertPdgToGeant3(Int_t pdgNumber) const
330 {
331  switch(pdgNumber) {
332 
333  case 22 : return 1; // photon
334  case -2112 : return 25; // anti-neutron
335  case -11 : return 2; // e+
336  case -3122 : return 26; // anti-Lambda
337  case 11 : return 3; // e-
338  case -3222 : return 27; // Sigma-
339  case 12 : return 4; // e-neutrino (NB: flavour undefined by Geant)
340  case -3212 : return 28; // Sigma0
341  case -13 : return 5; // mu+
342  case -3112 : return 29; // Sigma+ (PB)*/
343  case 13 : return 6; // mu-
344  case -3322 : return 30; // Xi0
345  case 111 : return 7; // pi0
346  case -3312 : return 31; // Xi+
347  case 211 : return 8; // pi+
348  case -3334 : return 32; // Omega+ (PB)
349  case -211 : return 9; // pi-
350  case -15 : return 33; // tau+
351  case 130 : return 10; // K long
352  case 15 : return 34; // tau-
353  case 321 : return 11; // K+
354  case 411 : return 35; // D+
355  case -321 : return 12; // K-
356  case -411 : return 36; // D-
357  case 2112 : return 13; // n
358  case 421 : return 37; // D0
359  case 2212 : return 14; // p
360  case -421 : return 38; // D0
361  case -2212 : return 15; // anti-proton
362  case 431 : return 39; // Ds+
363  case 310 : return 16; // K short
364  case -431 : return 40; // anti Ds-
365  case 221 : return 17; // eta
366  case 4122 : return 41; // Lamba_c+
367  case 3122 : return 18; // Lambda
368  case 24 : return 42; // W+
369  case 3222 : return 19; // Sigma+
370  case -24 : return 43; // W-
371  case 3212 : return 20; // Sigma0
372  case 23 : return 44; // Z
373  case 3112 : return 21; // Sigma-
374  case 3322 : return 22; // Xi0
375  case 3312 : return 23; // Xi-
376  case 3334 : return 24; // Omega- (PB)
377 
378  default : return 0;
379 
380  }
381 }
382 
383 ////////////////////////////////////////////////////////////////////////////////
384 ///
385 /// Converts the ISAJET Particle number into the PDG MC number
386 ///
387 
388 Int_t TDatabasePDG::ConvertIsajetToPdg(Int_t isaNumber) const
389 {
390  switch (isaNumber) {
391  case 1 : return 2; // UP .30000E+00 .67
392  case -1 : return -2; // UB .30000E+00 -.67
393  case 2 : return 1; // DN .30000E+00 -.33
394  case -2 : return -1; // DB .30000E+00 .33
395  case 3 : return 3; // ST .50000E+00 -.33
396  case -3 : return -3; // SB .50000E+00 .33
397  case 4 : return 4; // CH .16000E+01 .67
398  case -4 : return -4; // CB .16000E+01 -.67
399  case 5 : return 5; // BT .49000E+01 -.33
400  case -5 : return -5; // BB .49000E+01 .33
401  case 6 : return 6; // TP .17500E+03 .67
402  case -6 : return -6; // TB .17500E+03 -.67
403  case 9 : return 21; // GL 0. 0.00
404  case 80 : return 24; // W+ SIN2W=.23 1.00
405  case -80 : return -24; // W- SIN2W=.23 -1.00
406  case 90 : return 23; // Z0 SIN2W=.23 0.00
407  case 230 : return 311; // K0 .49767E+00 0.00
408  case -230 : return -311; // AK0 .49767E+00 0.00
409  case 330 : return 331; // ETAP .95760E+00 0.00
410  case 340 : return 0; // F- .20300E+01 -1.00
411  case -340 : return 0; // F+ .20300E+01 1.00
412  case 440 : return 441; // ETAC .29760E+01 0.00
413  case 111 : return 113; // RHO0 .77000E+00 0.00
414  case 121 : return 213; // RHO+ .77000E+00 1.00
415  case -121 : return -213; // RHO- .77000E+00 -1.00
416  case 221 : return 223; // OMEG .78260E+00 0.00
417  case 131 : return 323; // K*+ .88810E+00 1.00
418  case -131 : return -323; // K*- .88810E+00 -1.00
419  case 231 : return 313; // K*0 .89220E+00 0.00
420  case -231 : return -313; // AK*0 .89220E+00 0.00
421  case 331 : return 333; // PHI .10196E+01 0.00
422  case -140 : return 421; // D0
423  case 140 : return -421; // D0 bar
424  case 141 : return -423; // AD*0 .20060E+01 0.00
425  case -141 : return 423; // D*0 .20060E+01 0.00
426  case -240 : return -411; // D+
427  case 240 : return 411; // D-
428  case 241 : return -413; // D*- .20086E+01 -1.00
429  case -241 : return 413; // D*+ .20086E+01 1.00
430  case 341 : return 0; // F*- .21400E+01 -1.00
431  case -341 : return 0; // F*+ .21400E+01 1.00
432  case 441 : return 443; // JPSI .30970E+01 0.00
433 
434  // B-mesons, Bc still missing
435  case 250 : return 511; // B0
436  case -250 : return -511; // B0 bar
437  case 150 : return 521; // B+
438  case -150 : return -521; // B-
439  case 350 : return 531; // Bs 0
440  case -350 : return -531; // Bs bar
441  case 351 : return 533; // Bs* 0
442  case -351 : return -533; // Bs* bar
443  case 450 : return 541; // Bc +
444  case -450 : return -541; // Bc bar
445 
446  case 1140 : return 4222; // SC++ .24300E+01 2.00
447  case -1140 : return -4222; // ASC-- .24300E+01 -2.00
448  case 1240 : return 4212; // SC+ .24300E+01 1.00
449  case -1240 : return -4212; // ASC- .24300E+01 -1.00
450  case 2140 : return 4122; // LC+ .22600E+01 1.00
451  case -2140 : return -4122; // ALC- .22600E+01 -1.00
452  case 2240 : return 4112; // SC0 .24300E+01 0.00
453  case -2240 : return -4112; // ASC0 .24300E+01 0.00
454  case 1340 : return 0; // USC. .25000E+01 1.00
455  case -1340 : return 0; // AUSC. .25000E+01 -1.00
456  case 3140 : return 0; // SUC. .24000E+01 1.00
457  case -3140 : return 0; // ASUC. .24000E+01 -1.00
458  case 2340 : return 0; // DSC. .25000E+01 0.00
459  case -2340 : return 0; // ADSC. .25000E+01 0.00
460  case 3240 : return 0; // SDC. .24000E+01 0.00
461  case -3240 : return 0; // ASDC. .24000E+01 0.00
462  case 3340 : return 0; // SSC. .26000E+01 0.00
463  case -3340 : return 0; // ASSC. .26000E+01 0.00
464  case 1440 : return 0; // UCC. .35500E+01 2.00
465  case -1440 : return 0; // AUCC. .35500E+01 -2.00
466  case 2440 : return 0; // DCC. .35500E+01 1.00
467  case -2440 : return 0; // ADCC. .35500E+01 -1.00
468  case 3440 : return 0; // SCC. .37000E+01 1.00
469  case -3440 : return 0; // ASCC. .37000E+01 -1.00
470  case 1111 : return 2224; // DL++ .12320E+01 2.00
471  case -1111 : return -2224; // ADL-- .12320E+01 -2.00
472  case 1121 : return 2214; // DL+ .12320E+01 1.00
473  case -1121 : return -2214; // ADL- .12320E+01 -1.00
474  case 1221 : return 2114; // DL0 .12320E+01 0.00
475  case -1221 : return -2114; // ADL0 .12320E+01 0.00
476  case 2221 : return 1114; // DL- .12320E+01 -1.00
477  case -2221 : return -1114; // ADL+ .12320E+01 1.00
478  case 1131 : return 3224; // S*+ .13823E+01 1.00
479  case -1131 : return -3224; // AS*- .13823E+01 -1.00
480  case 1231 : return 3214; // S*0 .13820E+01 0.00
481  case -1231 : return -3214; // AS*0 .13820E+01 0.00
482  case 2231 : return 3114; // S*- .13875E+01 -1.00
483  case -2231 : return -3114; // AS*+ .13875E+01 1.00
484  case 1331 : return 3324; // XI*0 .15318E+01 0.00
485  case -1331 : return -3324; // AXI*0 .15318E+01 0.00
486  case 2331 : return 3314; // XI*- .15350E+01 -1.00
487  case -2331 : return -3314; // AXI*+ .15350E+01 1.00
488  case 3331 : return 3334; // OM- .16722E+01 -1.00
489  case -3331 : return -3334; // AOM+ .16722E+01 1.00
490  case 1141 : return 0; // UUC* .26300E+01 2.00
491  case -1141 : return 0; // AUUC* .26300E+01 -2.00
492  case 1241 : return 0; // UDC* .26300E+01 1.00
493  case -1241 : return 0; // AUDC* .26300E+01 -1.00
494  case 2241 : return 0; // DDC* .26300E+01 0.00
495  case -2241 : return 0; // ADDC* .26300E+01 0.00
496  case 1341 : return 0; // USC* .27000E+01 1.00
497  case -1341 : return 0; // AUSC* .27000E+01 -1.00
498  case 2341 : return 0; // DSC* .27000E+01 0.00
499  case -2341 : return 0; // ADSC* .27000E+01 0.00
500  case 3341 : return 0; // SSC* .28000E+01 0.00
501  case -3341 : return 0; // ASSC* .28000E+01 0.00
502  case 1441 : return 0; // UCC* .37500E+01 2.00
503  case -1441 : return 0; // AUCC* .37500E+01 -2.00
504  case 2441 : return 0; // DCC* .37500E+01 1.00
505  case -2441 : return 0; // ADCC* .37500E+01 -1.00
506  case 3441 : return 0; // SCC* .39000E+01 1.00
507  case -3441 : return 0; // ASCC* .39000E+01 -1.00
508  case 4441 : return 0; // CCC* .48000E+01 2.00
509  case -4441 : return 0; // ACCC* .48000E+01 -2.00
510  case 10 : return 22; // Photon
511  case 12 : return 11; // Electron
512  case -12 : return -11; // Positron
513  case 14 : return 13; // Muon-
514  case -14 : return -13; // Muon+
515  case 16 : return 15; // Tau-
516  case -16 : return -15; // Tau+
517  case 11 : return 12; // Neutrino e
518  case -11 : return -12; // Anti Neutrino e
519  case 13 : return 14; // Neutrino Muon
520  case -13 : return -14; // Anti Neutrino Muon
521  case 15 : return 16; // Neutrino Tau
522  case -15 : return -16; // Anti Neutrino Tau
523  case 110 : return 111; // Pion0
524  case 120 : return 211; // Pion+
525  case -120 : return -211; // Pion-
526  case 220 : return 221; // Eta
527  case 130 : return 321; // Kaon+
528  case -130 : return -321; // Kaon-
529  case -20 : return 130; // Kaon Long
530  case 20 : return 310; // Kaon Short
531 
532  // baryons
533  case 1120 : return 2212; // Proton
534  case -1120 : return -2212; // Anti Proton
535  case 1220 : return 2112; // Neutron
536  case -1220 : return -2112; // Anti Neutron
537  case 2130 : return 3122; // Lambda
538  case -2130 : return -3122; // Lambda bar
539  case 1130 : return 3222; // Sigma+
540  case -1130 : return -3222; // Sigma bar -
541  case 1230 : return 3212; // Sigma0
542  case -1230 : return -3212; // Sigma bar 0
543  case 2230 : return 3112; // Sigma-
544  case -2230 : return -3112; // Sigma bar +
545  case 1330 : return 3322; // Xi0
546  case -1330 : return -3322; // Xi bar 0
547  case 2330 : return 3312; // Xi-
548  case -2330 : return -3312; // Xi bar +
549  default : return 0; // isajet or pdg number does not exist
550  }
551 }
552 
553 ////////////////////////////////////////////////////////////////////////////////
554 /// read list of particles from a file
555 /// if the particle list does not exist, it is created, otherwise
556 /// particles are added to the existing list
557 /// See $ROOTSYS/etc/pdg_table.txt to see the file format
558 
559 void TDatabasePDG::ReadPDGTable(const char *FileName)
560 {
561  if (fParticleList == 0) {
562  fParticleList = new THashList;
563  fListOfClasses = new TObjArray;
564  }
565 
566  TString default_name;
567  const char *fn;
568 
569  if (!FileName[0]) {
570  default_name = "pdg_table.txt";
571  gSystem->PrependPathName(TROOT::GetEtcDir(), default_name);
572  fn = gEnv->GetValue("Root.DatabasePDG", default_name.Data());
573  } else {
574  fn = FileName;
575  }
576 
577  FILE* file = fopen(fn,"r");
578  if (file == 0) {
579  Error("ReadPDGTable","Could not open PDG particle file %s",fn);
580  return;
581  }
582 
583  char c[512];
584  Int_t class_number, anti, isospin, i3, spin, tracking_code;
585  Int_t ich, kf, nch, charge;
586  char name[30], class_name[30];
587  Double_t mass, width, branching_ratio;
588  Int_t dau[20];
589 
590  Int_t idecay, decay_type, flavor, ndau, stable;
591 
592  Int_t input;
593  while ( (input=getc(file)) != EOF) {
594  c[0] = input;
595  if (c[0] != '#') {
596  ungetc(c[0],file);
597  // read channel number
598  // coverity [secure_coding : FALSE]
599  if (fscanf(file,"%i",&ich)) {;}
600  // coverity [secure_coding : FALSE]
601  if (fscanf(file,"%s",name )) {;}
602  // coverity [secure_coding : FALSE]
603  if (fscanf(file,"%i",&kf )) {;}
604  // coverity [secure_coding : FALSE]
605  if (fscanf(file,"%i",&anti )) {;}
606 
607  if (kf < 0) {
608  AddAntiParticle(name,kf);
609  // nothing more on this line
610  if (fgets(c,200,file)) {;}
611  } else {
612  // coverity [secure_coding : FALSE]
613  if (fscanf(file,"%i",&class_number)) {;}
614  // coverity [secure_coding : FALSE]
615  if (fscanf(file,"%s",class_name)) {;}
616  // coverity [secure_coding : FALSE]
617  if (fscanf(file,"%i",&charge)) {;}
618  // coverity [secure_coding : FALSE]
619  if (fscanf(file,"%le",&mass)) {;}
620  // coverity [secure_coding : FALSE]
621  if (fscanf(file,"%le",&width)) {;}
622  // coverity [secure_coding : FALSE]
623  if (fscanf(file,"%i",&isospin)) {;}
624  // coverity [secure_coding : FALSE]
625  if (fscanf(file,"%i",&i3)) {;}
626  // coverity [secure_coding : FALSE]
627  if (fscanf(file,"%i",&spin)) {;}
628  // coverity [secure_coding : FALSE]
629  if (fscanf(file,"%i",&flavor)) {;}
630  // coverity [secure_coding : FALSE]
631  if (fscanf(file,"%i",&tracking_code)) {;}
632  // coverity [secure_coding : FALSE]
633  if (fscanf(file,"%i",&nch)) {;}
634  // nothing more on this line
635  if (fgets(c,200,file)) {;}
636  if (width > 1e-10) stable = 0;
637  else stable = 1;
638 
639  // create particle
640 
641  TParticlePDG* part = AddParticle(name,
642  name,
643  mass,
644  stable,
645  width,
646  charge,
647  class_name,
648  kf,
649  anti,
650  tracking_code);
651 
652  if (nch) {
653  // read in decay channels
654  ich = 0;
655  Int_t c_input = 0;
656  while ( ((c_input=getc(file)) != EOF) && (ich <nch)) {
657  c[0] = c_input;
658  if (c[0] != '#') {
659  ungetc(c[0],file);
660 
661  // coverity [secure_coding : FALSE]
662  if (fscanf(file,"%i",&idecay)) {;}
663  // coverity [secure_coding : FALSE]
664  if (fscanf(file,"%i",&decay_type)) {;}
665  // coverity [secure_coding : FALSE]
666  if (fscanf(file,"%le",&branching_ratio)) {;}
667  // coverity [secure_coding : FALSE]
668  if (fscanf(file,"%i",&ndau)) {;}
669  for (int idau=0; idau<ndau; idau++) {
670  // coverity [secure_coding : FALSE]
671  if (fscanf(file,"%i",&dau[idau])) {;}
672  }
673  // add decay channel
674 
675  if (part) part->AddDecayChannel(decay_type,branching_ratio,ndau,dau);
676  ich++;
677  }
678  // skip end of line
679  if (fgets(c,200,file)) {;}
680  }
681  }
682  }
683  } else {
684  // skip end of line
685  if (fgets(c,200,file)) {;}
686  }
687  }
688  // in the end loop over the antiparticles and
689  // define their decay lists
690  TIter it(fParticleList);
691 
692  Int_t code[20];
693  TParticlePDG *ap, *p, *daughter;
694  TDecayChannel *dc;
695 
696  while ((p = (TParticlePDG*) it.Next())) {
697 
698  // define decay channels for antiparticles
699  if (p->PdgCode() < 0) {
700  ap = GetParticle(-p->PdgCode());
701  if (!ap) continue;
702  nch = ap->NDecayChannels();
703  for (ich=0; ich<nch; ich++) {
704  dc = ap->DecayChannel(ich);
705  if (!dc) continue;
706  ndau = dc->NDaughters();
707  for (int i=0; i<ndau; i++) {
708  // conserve CPT
709 
710  code[i] = dc->DaughterPdgCode(i);
711  daughter = GetParticle(code[i]);
712  if (daughter && daughter->AntiParticle()) {
713  // this particle does have an
714  // antiparticle
715  code[i] = -code[i];
716  }
717  }
718  p->AddDecayChannel(dc->MatrixElementCode(),
719  dc->BranchingRatio(),
720  dc->NDaughters(),
721  code);
722  }
723  p->SetAntiParticle(ap);
724  ap->SetAntiParticle(p);
725  }
726  }
727 
728  fclose(file);
729  return;
730 }
731 
732 
733 ////////////////////////////////////////////////////////////////////////////////
734 ///browse data base
735 
736 void TDatabasePDG::Browse(TBrowser* b)
737 {
738  if (fListOfClasses ) fListOfClasses->Browse(b);
739 }
740 
741 
742 ////////////////////////////////////////////////////////////////////////////////
743 /// write contents of the particle DB into a file
744 
745 Int_t TDatabasePDG::WritePDGTable(const char *filename)
746 {
747  if (fParticleList == 0) {
748  Error("WritePDGTable","Do not have a valid PDG particle list;"
749  " consider loading it with ReadPDGTable first.");
750  return -1;
751  }
752 
753  FILE *file = fopen(filename,"w");
754  if (file == 0) {
755  Error("WritePDGTable","Could not open PDG particle file %s",filename);
756  return -1;
757  }
758 
759  fprintf(file,"#--------------------------------------------------------------------\n");
760  fprintf(file,"# i NAME............. KF AP CLASS Q MASS WIDTH 2*I+1 I3 2*S+1 FLVR TrkCod N(dec)\n");
761  fprintf(file,"#--------------------------------------------------------------------\n");
762 
763  Int_t nparts=fParticleList->GetEntries();
764  for(Int_t i=0;i<nparts;++i) {
765  TParticlePDG *p = dynamic_cast<TParticlePDG*>(fParticleList->At(i));
766  if(!p) continue;
767 
768  Int_t ich=i+1;
769  Int_t kf=p->PdgCode();
770  fprintf(file,"%5i %-20s %- 6i ", ich, p->GetName(), kf);
771 
772  Int_t anti=p->AntiParticle() ? 1:0;
773  if(kf<0) {
774  for(Int_t j=0;j<nparts;++j) {
775  TParticlePDG *dummy = dynamic_cast<TParticlePDG*>(fParticleList->At(j));
776  if(dummy==p->AntiParticle()) {
777  anti=j+1;
778  break;
779  }
780  }
781  fprintf(file,"%i 0\n",anti);
782  continue;
783  }
784 
785  fprintf(file,"%i ",anti);
786  fprintf(file,"%i ",100);
787  fprintf(file,"%s ",p->ParticleClass());
788  fprintf(file,"% i ",(Int_t)p->Charge());
789  fprintf(file,"%.5le ",p->Mass());
790  fprintf(file,"%.5le ",p->Width());
791  fprintf(file,"%i ",(Int_t)p->Isospin());
792  fprintf(file,"%i ",(Int_t)p->I3());
793  fprintf(file,"%i ",(Int_t)p->Spin());
794  fprintf(file,"%i ",-1);
795  fprintf(file,"%i ",p->TrackingCode());
796  Int_t nch=p->NDecayChannels();
797  fprintf(file,"%i\n",nch);
798  if(nch==0) {
799  continue;
800  }
801  fprintf(file,"#----------------------------------------------------------------------\n");
802  fprintf(file,"# decay type(PY6) BR Nd daughters(codes, then names)\n");
803  fprintf(file,"#----------------------------------------------------------------------\n");
804  for(Int_t j=0;j<nch;++j) {
805  TDecayChannel *dc=p->DecayChannel(j);
806  if (!dc) continue;
807  fprintf(file,"%9i ",dc->Number()+1);
808  fprintf(file,"%3i ",dc->MatrixElementCode());
809  fprintf(file,"%.5le ",dc->BranchingRatio());
810  Int_t ndau=dc->NDaughters();
811  fprintf(file,"%3i ",ndau);
812  for (int idau=0; idau<ndau; idau++) {
813  fprintf(file,"%- 6i ",dc->DaughterPdgCode(idau));
814  }
815  for (int idau=0; idau<ndau; idau++) {
816  TParticlePDG *dummy=GetParticle(dc->DaughterPdgCode(idau));
817  if(dummy)
818  fprintf(file,"%-10s ",dummy->GetName());
819  else
820  fprintf(file,"%-10s ","???");
821  }
822  fprintf(file,"\n");
823  }
824  }
825  fclose(file);
826  return nparts;
827 }