Logo ROOT  

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