ROOT logo
// @(#)root/eg:$Id: TDatabasePDG.cxx 29003 2009-06-15 15:07:20Z brun $
// Author: Pasha Murat   12/02/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#include "RConfigure.h"
#include "TROOT.h"
#include "TEnv.h"
#include "THashList.h"
#include "TExMap.h"
#include "TSystem.h"
#include "TDatabasePDG.h"
#include "TDecayChannel.h"
#include "TParticlePDG.h"
#include <stdlib.h>


////////////////////////////////////////////////////////////////////////
//
//  Particle database manager class
//
//  This manager creates a list of particles which by default is
//  initialised from with the constants used by PYTHIA6 (plus some
//  other particles added). See definition and the format of the default
//  particle list in $ROOTSYS/etc/pdg_table.txt
//
//  there are 2 ways of redefining the name of the file containing the
//  particle properties
//
//  1. one can define the name in .rootrc file:
//
//  Root.DatabasePDG: $(HOME)/my_pdg_table.txt
//
//  2. one can use TDatabasePDG::ReadPDGTable method explicitly:
//
//     - TDatabasePDG *pdg = new TDatabasePDG();
//     - pdg->ReadPDGtable(filename)
//
//  See TParticlePDG for the description of a static particle properties.
//  See TParticle    for the description of a dynamic particle particle.
//
////////////////////////////////////////////////////////////////////////

ClassImp(TDatabasePDG)

TDatabasePDG*  TDatabasePDG::fgInstance = 0;

//______________________________________________________________________________
TDatabasePDG::TDatabasePDG(): TNamed("PDGDB","The PDG particle data base")
{
  // Create PDG database. Initialization of the DB has to be done via explicit
  // call to ReadDataBasePDG (also done by GetParticle methods)

   fParticleList  = 0;
   fPdgMap        = 0;
   fListOfClasses = 0;
      if (fgInstance) {
      Warning("TDatabasePDG", "object already instantiated");
   } else {
      fgInstance = this;
      gROOT->GetListOfSpecials()->Add(this);
   }
}

//______________________________________________________________________________
TDatabasePDG::~TDatabasePDG()
{
   // Cleanup the PDG database.

   if (fParticleList) {
      fParticleList->Delete();
      delete fParticleList;
      delete fPdgMap;
   }
                                // classes do not own particles...
   if (fListOfClasses) delete fListOfClasses;
   gROOT->GetListOfSpecials()->Remove(this);
   fgInstance = 0;
}

//______________________________________________________________________________
TDatabasePDG*  TDatabasePDG::Instance()
{
   //static function
   return (fgInstance) ? (TDatabasePDG*) fgInstance : new TDatabasePDG();
}

//______________________________________________________________________________
void TDatabasePDG::BuildPdgMap() const
{
   // Build fPdgMap mapping pdg-code to particle.
   //
   // Initial size is set so as to be able to hold at least 600
   // particles: 521 in default table, ALICE adds 54 more.
   // To be revisited after LHC discovers SUSY.

   fPdgMap = new TExMap(4*TMath::Max(600, fParticleList->GetEntries())/3 + 3);
   TIter next(fParticleList);
   TParticlePDG *p;
   while ((p = (TParticlePDG*)next())) {
      fPdgMap->Add((Long_t)p->PdgCode(), (Long_t)p);
   }
}

//______________________________________________________________________________
TParticlePDG* TDatabasePDG::AddParticle(const char *name, const char *title,
                                        Double_t mass, Bool_t stable,
                                        Double_t width, Double_t charge,
                                        const char* ParticleClass,
                                        Int_t PDGcode,
                                        Int_t Anti,
                                        Int_t TrackingCode)
{
  //
  //  Particle definition normal constructor. If the particle is set to be
  //  stable, the decay width parameter does have no meaning and can be set to
  //  any value. The parameters granularity, LowerCutOff and HighCutOff are
  //  used for the construction of the mean free path look up tables. The
  //  granularity will be the number of logwise energy points for which the
  //  mean free path will be calculated.
  //

   TParticlePDG* old = GetParticle(PDGcode);

   if (old) {
      printf(" *** TDatabasePDG::AddParticle: particle with PDGcode=%d already defined\n",PDGcode);
      return 0;
   }

   TParticlePDG* p = new TParticlePDG(name, title, mass, stable, width,
                                     charge, ParticleClass, PDGcode, Anti,
                                     TrackingCode);
   fParticleList->Add(p);
   if (fPdgMap)
      fPdgMap->Add((Long_t)PDGcode, (Long_t)p);

   TParticleClassPDG* pclass = GetParticleClass(ParticleClass);

   if (!pclass) {
      pclass = new TParticleClassPDG(ParticleClass);
      fListOfClasses->Add(pclass);
   }

   pclass->AddParticle(p);

   return p;
}

//______________________________________________________________________________
TParticlePDG* TDatabasePDG::AddAntiParticle(const char* Name, Int_t PdgCode)
{
   // assuming particle has already been defined

   TParticlePDG* old = GetParticle(PdgCode);

   if (old) {
      printf(" *** TDatabasePDG::AddAntiParticle: can't redefine parameters\n");
      return NULL;
   }

   Int_t pdg_code  = abs(PdgCode);
   TParticlePDG* p = GetParticle(pdg_code);

   TParticlePDG* ap = AddParticle(Name,
                                  Name,
                                  p->Mass(),
                                  1,
                                  p->Width(),
                                  -p->Charge(),
                                  p->ParticleClass(),
                                  PdgCode,
                                  1,
                                  p->TrackingCode());
   return ap;
}


//______________________________________________________________________________
TParticlePDG *TDatabasePDG::GetParticle(const char *name) const
{
   //
   //  Get a pointer to the particle object according to the name given
   //

   if (fParticleList == 0)  ((TDatabasePDG*)this)->ReadPDGTable();

   TParticlePDG *def = (TParticlePDG *)fParticleList->FindObject(name);
//     if (!def) {
//        Error("GetParticle","No match for %s exists!",name);
//     }
   return def;
}

//______________________________________________________________________________
TParticlePDG *TDatabasePDG::GetParticle(Int_t PDGcode) const
{
   //
   //  Get a pointer to the particle object according to the MC code number
   //

   if (fParticleList == 0)  ((TDatabasePDG*)this)->ReadPDGTable();
   if (fPdgMap       == 0)  BuildPdgMap();

   return (TParticlePDG*) fPdgMap->GetValue((Long_t)PDGcode);
}

//______________________________________________________________________________
void TDatabasePDG::Print(Option_t *option) const
{
   // Print contents of PDG database.

   if (fParticleList == 0)  ((TDatabasePDG*)this)->ReadPDGTable();

   TIter next(fParticleList);
   TParticlePDG *p;
   while ((p = (TParticlePDG *)next())) {
      p->Print(option);
   }
}

//______________________________________________________________________________
Int_t TDatabasePDG::ConvertGeant3ToPdg(Int_t Geant3number) {
  // Converts Geant3 particle codes to PDG convention. (Geant4 uses
  // PDG convention already)
  // Source: BaBar User Guide, Neil I. Geddes,
  //
  //Begin_Html
  /*
   see <A href="http://www.slac.stanford.edu/BFROOT/www/Computing/Environment/NewUser/htmlbug/node51.html"> Conversion table</A>
  */
  //End_Html
  // with some fixes by PB, marked with (PB) below. Checked against
  // PDG listings from 2000.
  //
  // Paul Balm, Nov 19, 2001

   switch(Geant3number) {

      case 1   : return 22;       // photon
      case 25  : return -2112;    // anti-neutron
      case 2   : return -11;      // e+
      case 26  : return -3122;    // anti-Lambda
      case 3   : return 11;       // e-
      case 27  : return -3222;    // Sigma-
      case 4   : return 12;       // e-neutrino (NB: flavour undefined by Geant)
      case 28  : return -3212;    // Sigma0
      case 5   : return -13;      // mu+
      case 29  : return -3112;    // Sigma+ (PB)*/
      case 6   : return 13;       // mu-
      case 30  : return -3322;    // Xi0
      case 7   : return 111;      // pi0
      case 31  : return -3312;    // Xi+
      case 8   : return 211;      // pi+
      case 32  : return -3334;    // Omega+ (PB)
      case 9   : return -211;     // pi-
      case 33  : return -15;      // tau+
      case 10  : return 130;      // K long
      case 34  : return 15;       // tau-
      case 11  : return 321;      // K+
      case 35  : return 411;      // D+
      case 12  : return -321;     // K-
      case 36  : return -411;     // D-
      case 13  : return 2112;     // n
      case 37  : return 421;      // D0
      case 14  : return 2212;     // p
      case 38  : return -421;     // D0
      case 15  : return -2212;    // anti-proton
      case 39  : return 431;      // Ds+
      case 16  : return 310;      // K short
      case 40  : return -431;     // anti Ds-
      case 17  : return 221;      // eta
      case 41  : return 4122;     // Lamba_c+
      case 18  : return 3122;     // Lambda
      case 42  : return 24;       // W+
      case 19  : return 3222;     // Sigma+
      case 43  : return -24;      // W-
      case 20  : return 3212;     // Sigma0
      case 44  : return 23;       // Z
      case 21  : return 3112;     // Sigma-
      case 45  : return 0;        // deuteron
      case 22  : return 3322;     // Xi0
      case 46  : return 0;        // triton
      case 23  : return 3312;     // Xi-
      case 47  : return 0;        // alpha
      case 24  : return 3334;     // Omega- (PB)
      case 48  : return 0;        // G nu ? PDG ID 0 is undefined

      default  : return 0;

   }
}

//______________________________________________________________________________
Int_t TDatabasePDG::ConvertPdgToGeant3(Int_t pdgNumber) {
   // Converts pdg code to geant3 id

   switch(pdgNumber) {

      case   22     : return  1;    // photon
      case   -2112  : return  25;   // anti-neutron
      case   -11    : return  2;    // e+
      case   -3122  : return  26;   // anti-Lambda
      case   11     : return  3;    // e-
      case   -3222  : return  27;   // Sigma-
      case   12     : return  4;    // e-neutrino (NB: flavour undefined by Geant)
      case   -3212  : return  28;   // Sigma0
      case   -13    : return  5;    // mu+
      case   -3112  : return  29;   // Sigma+ (PB)*/
      case   13     : return  6;    // mu-
      case   -3322  : return  30;   // Xi0
      case   111    : return  7;    // pi0
      case   -3312  : return  31;   // Xi+
      case   211    : return  8;    // pi+
      case   -3334  : return  32;   // Omega+ (PB)
      case   -211   : return  9;    // pi-
      case   -15    : return  33;   // tau+
      case   130    : return  10;   // K long
      case   15     : return  34;   // tau-
      case   321    : return  11;   // K+
      case   411    : return  35;   // D+
      case   -321   : return  12;   // K-
      case   -411   : return  36;   // D-
      case   2112   : return  13;   // n
      case   421    : return  37;   // D0
      case   2212   : return  14;   // p
      case   -421   : return  38;   // D0
      case   -2212  : return  15;   // anti-proton
      case   431    : return  39;   // Ds+
      case   310    : return  16;   // K short
      case   -431   : return  40;   // anti Ds-
      case   221    : return  17;   // eta
      case   4122   : return  41;   // Lamba_c+
      case   3122   : return  18;   // Lambda
      case   24     : return  42;   // W+
      case   3222   : return  19;   // Sigma+
      case   -24    : return  43;   // W-
      case   3212   : return  20;   // Sigma0
      case   23     : return  44;   // Z
      case   3112   : return  21;   // Sigma-
      case   3322   : return  22;   // Xi0
      case   3312   : return  23;   // Xi-
      case   3334   : return  24;   // Omega- (PB)

      default  : return 0;

   }
}

//______________________________________________________________________________
Int_t TDatabasePDG::ConvertIsajetToPdg(Int_t isaNumber)
{
//
//  Converts the ISAJET Particle number into the PDG MC number
//
   switch (isaNumber) {
      case     1 : return     2; //     UP        .30000E+00       .67
      case    -1 : return    -2; //     UB        .30000E+00      -.67
      case     2 : return     1; //     DN        .30000E+00      -.33
      case    -2 : return    -1; //     DB        .30000E+00       .33
      case     3 : return     3; //     ST        .50000E+00      -.33
      case    -3 : return    -3; //     SB        .50000E+00       .33
      case     4 : return     4; //     CH        .16000E+01       .67
      case    -4 : return    -4; //     CB        .16000E+01      -.67
      case     5 : return     5; //     BT        .49000E+01      -.33
      case    -5 : return    -5; //     BB        .49000E+01       .33
      case     6 : return     6; //     TP        .17500E+03       .67
      case    -6 : return    -6; //     TB        .17500E+03      -.67
      case     9 : return    21; //     GL       0.               0.00
      case    80 : return    24; //     W+        SIN2W=.23       1.00
      case   -80 : return   -24; //     W-        SIN2W=.23      -1.00
      case    90 : return    23; //     Z0        SIN2W=.23       0.00
      case   230 : return   311; //     K0        .49767E+00      0.00
      case  -230 : return  -311; //     AK0       .49767E+00      0.00
      case   330 : return   331; //     ETAP      .95760E+00      0.00
      case   340 : return     0; //     F-        .20300E+01     -1.00
      case  -340 : return     0; //     F+        .20300E+01      1.00
      case   440 : return   441; //     ETAC      .29760E+01      0.00
      case   111 : return   113; //     RHO0      .77000E+00      0.00
      case   121 : return   213; //     RHO+      .77000E+00      1.00
      case  -121 : return  -213; //     RHO-      .77000E+00     -1.00
      case   221 : return   223; //     OMEG      .78260E+00      0.00
      case   131 : return   323; //     K*+       .88810E+00      1.00
      case  -131 : return  -323; //     K*-       .88810E+00     -1.00
      case   231 : return   313; //     K*0       .89220E+00      0.00
      case  -231 : return  -313; //     AK*0      .89220E+00      0.00
      case   331 : return   333; //     PHI       .10196E+01      0.00
      case  -140 : return   421; //     D0
      case   140 : return  -421; //     D0 bar
      case   141 : return  -423; //     AD*0      .20060E+01      0.00
      case  -141 : return   423; //     D*0       .20060E+01      0.00
      case  -240 : return  -411; //     D+
      case   240 : return   411; //     D-
      case   241 : return  -413; //     D*-       .20086E+01     -1.00
      case  -241 : return   413; //     D*+       .20086E+01      1.00
      case   341 : return     0; //     F*-       .21400E+01     -1.00
      case  -341 : return     0; //     F*+       .21400E+01      1.00
      case   441 : return   443; //     JPSI      .30970E+01      0.00

                                        // B-mesons, Bc still missing
      case   250 : return   511; // B0
      case  -250 : return  -511; // B0 bar
      case   150 : return   521; // B+
      case  -150 : return  -521; // B-
      case   350 : return   531; // Bs  0
      case  -350 : return  -531; // Bs  bar
      case   351 : return   533; // Bs* 0
      case  -351 : return  -533; // Bs* bar
      case   450 : return   541; // Bc  +
      case  -450 : return  -541; // Bc  bar

      case  1140 : return  4222; //     SC++      .24300E+01      2.00
      case -1140 : return -4222; //     ASC--     .24300E+01     -2.00
      case  1240 : return  4212; //     SC+       .24300E+01      1.00
      case -1240 : return -4212; //     ASC-      .24300E+01     -1.00
      case  2140 : return  4122; //     LC+       .22600E+01      1.00
      case -2140 : return -4122; //     ALC-      .22600E+01     -1.00
      case  2240 : return  4112; //     SC0       .24300E+01      0.00
      case -2240 : return -4112; //     ASC0      .24300E+01      0.00
      case  1340 : return     0; //     USC.      .25000E+01      1.00
      case -1340 : return     0; //     AUSC.     .25000E+01     -1.00
      case  3140 : return     0; //     SUC.      .24000E+01      1.00
      case -3140 : return     0; //     ASUC.     .24000E+01     -1.00
      case  2340 : return     0; //     DSC.      .25000E+01      0.00
      case -2340 : return     0; //     ADSC.     .25000E+01      0.00
      case  3240 : return     0; //     SDC.      .24000E+01      0.00
      case -3240 : return     0; //     ASDC.     .24000E+01      0.00
      case  3340 : return     0; //     SSC.      .26000E+01      0.00
      case -3340 : return     0; //     ASSC.     .26000E+01      0.00
      case  1440 : return     0; //     UCC.      .35500E+01      2.00
      case -1440 : return     0; //     AUCC.     .35500E+01     -2.00
      case  2440 : return     0; //     DCC.      .35500E+01      1.00
      case -2440 : return     0; //     ADCC.     .35500E+01     -1.00
      case  3440 : return     0; //     SCC.      .37000E+01      1.00
      case -3440 : return     0; //     ASCC.     .37000E+01     -1.00
      case  1111 : return  2224; //     DL++      .12320E+01      2.00
      case -1111 : return -2224; //     ADL--     .12320E+01     -2.00
      case  1121 : return  2214; //     DL+       .12320E+01      1.00
      case -1121 : return -2214; //     ADL-      .12320E+01     -1.00
      case  1221 : return  2114; //     DL0       .12320E+01      0.00
      case -1221 : return -2114; //     ADL0      .12320E+01      0.00
      case  2221 : return   1114; //     DL-       .12320E+01     -1.00
      case -2221 : return -1114; //     ADL+      .12320E+01      1.00
      case  1131 : return  3224; //     S*+       .13823E+01      1.00
      case -1131 : return -3224; //     AS*-      .13823E+01     -1.00
      case  1231 : return  3214; //     S*0       .13820E+01      0.00
      case -1231 : return -3214; //     AS*0      .13820E+01      0.00
      case  2231 : return  3114; //     S*-       .13875E+01     -1.00
      case -2231 : return -3114; //     AS*+      .13875E+01      1.00
      case  1331 : return  3324; //     XI*0      .15318E+01      0.00
      case -1331 : return -3324; //     AXI*0     .15318E+01      0.00
      case  2331 : return  3314; //     XI*-      .15350E+01     -1.00
      case -2331 : return -3314; //     AXI*+     .15350E+01      1.00
      case  3331 : return  3334; //     OM-       .16722E+01     -1.00
      case -3331 : return -3334; //     AOM+      .16722E+01      1.00
      case  1141 : return     0; //     UUC*      .26300E+01      2.00
      case -1141 : return     0; //     AUUC*     .26300E+01     -2.00
      case  1241 : return     0; //     UDC*      .26300E+01      1.00
      case -1241 : return     0; //     AUDC*     .26300E+01     -1.00
      case  2241 : return     0; //     DDC*      .26300E+01      0.00
      case -2241 : return     0; //     ADDC*     .26300E+01      0.00
      case  1341 : return     0; //     USC*      .27000E+01      1.00
      case -1341 : return     0; //     AUSC*     .27000E+01     -1.00
      case  2341 : return     0; //     DSC*      .27000E+01      0.00
      case -2341 : return     0; //     ADSC*     .27000E+01      0.00
      case  3341 : return     0; //     SSC*      .28000E+01      0.00
      case -3341 : return     0; //     ASSC*     .28000E+01      0.00
      case  1441 : return     0; //     UCC*      .37500E+01      2.00
      case -1441 : return     0; //     AUCC*     .37500E+01     -2.00
      case  2441 : return     0; //     DCC*      .37500E+01      1.00
      case -2441 : return     0; //     ADCC*     .37500E+01     -1.00
      case  3441 : return     0; //     SCC*      .39000E+01      1.00
      case -3441 : return     0; //     ASCC*     .39000E+01     -1.00
      case  4441 : return     0; //     CCC*      .48000E+01      2.00
      case -4441 : return     0; //     ACCC*     .48000E+01     -2.00
      case    10 : return    22; // Photon
      case    12 : return    11; // Electron
      case   -12 : return   -11; // Positron
      case    14 : return    13; // Muon-
      case   -14 : return   -13; // Muon+
      case    16 : return    15; // Tau-
      case   -16 : return   -15; // Tau+
      case    11 : return    12; // Neutrino e
      case   -11 : return   -12; // Anti Neutrino e
      case    13 : return    14; // Neutrino Muon
      case   -13 : return   -14; // Anti Neutrino Muon
      case    15 : return    16; // Neutrino Tau
      case   -15 : return   -16; // Anti Neutrino Tau
      case   110 : return   111; // Pion0
      case   120 : return   211; // Pion+
      case  -120 : return  -211; // Pion-
      case   220 : return   221; // Eta
      case   130 : return   321; // Kaon+
      case  -130 : return  -321; // Kaon-
      case   -20 : return   130; // Kaon Long
      case    20 : return   310; // Kaon Short

                                        // baryons
      case  1120 : return  2212; // Proton
      case -1120 : return -2212; // Anti Proton
      case  1220 : return  2112; // Neutron
      case -1220 : return -2112; // Anti Neutron
      case  2130 : return  3122; // Lambda
      case -2130 : return -3122; // Lambda bar
      case  1130 : return  3222; // Sigma+
      case -1130 : return -3222; // Sigma bar -
      case  1230 : return  3212; // Sigma0
      case -1230 : return -3212; // Sigma bar 0
      case  2230 : return  3112; // Sigma-
      case -2230 : return -3112; // Sigma bar +
      case  1330 : return  3322; // Xi0
      case -1330 : return -3322; // Xi bar 0
      case  2330 : return  3312; // Xi-
      case -2330 : return -3312; // Xi bar +
      default :    return 0;      // isajet or pdg number does not exist
   }
}

//______________________________________________________________________________
void TDatabasePDG::ReadPDGTable(const char *FileName)
{
   // read list of particles from a file
   // if the particle list does not exist, it is created, otherwise
   // particles are added to the existing list
   // See $ROOTSYS/etc/pdg_table.txt to see the file format

   if (fParticleList == 0) {
      fParticleList  = new THashList;
      fListOfClasses = new TObjArray;
   }

   TString default_name;
   const char *fn;

   if (strlen(FileName) == 0) {
#ifdef ROOTETCDIR
      default_name.Form("%s/pdg_table.txt", ROOTETCDIR);
#else
      default_name.Form("%s/etc/pdg_table.txt", gSystem->Getenv("ROOTSYS"));
#endif
      fn = gEnv->GetValue("Root.DatabasePDG", default_name.Data());
   } else {
      fn = FileName;
   }

   FILE* file = fopen(fn,"r");
   if (file == 0) {
      Error("ReadPDGTable","Could not open PDG particle file %s",fn);
      return;
   }

   char      c[512];
   Int_t     class_number, anti, isospin, i3, spin, tracking_code;
   Int_t     ich, kf, nch, charge;
   char      name[30], class_name[30];
   Double_t  mass, width, branching_ratio;
   Int_t     dau[20];

   Int_t     idecay, decay_type, flavor, ndau;

   while ( (c[0]=getc(file)) != EOF) {

      if (c[0] != '#') {
         ungetc(c[0],file);
         // read channel number
         fscanf(file,"%i",&ich);
         fscanf(file,"%s",name  );
         fscanf(file,"%i",&kf   );
         fscanf(file,"%i",&anti );

         if (kf < 0) {
            AddAntiParticle(name,kf);
            // nothing more on this line
            fgets(c,200,file);
         } else {
            fscanf(file,"%i",&class_number);
            fscanf(file,"%s",class_name);
            fscanf(file,"%i",&charge);
            fscanf(file,"%le",&mass);
            fscanf(file,"%le",&width);
            fscanf(file,"%i",&isospin);
            fscanf(file,"%i",&i3);
            fscanf(file,"%i",&spin);
            fscanf(file,"%i",&flavor);
            fscanf(file,"%i",&tracking_code);
            fscanf(file,"%i",&nch);
            // nothing more on this line
            fgets(c,200,file);


            // create particle

            TParticlePDG* part = AddParticle(name,
                                             name,
                                             mass,
                                             1,
                                             width,
                                             charge,
                                             class_name,
                                             kf,
                                             anti,
                                             tracking_code);

            if (nch) {
               // read in decay channels
               ich = 0;
               while ( ((c[0]=getc(file)) != EOF) && (ich <nch)) {
                  if (c[0] != '#') {
                     ungetc(c[0],file);

                     fscanf(file,"%i",&idecay);
                     fscanf(file,"%i",&decay_type);
                     fscanf(file,"%le",&branching_ratio);
                     fscanf(file,"%i",&ndau);
                     for (int idau=0; idau<ndau; idau++) {
                        fscanf(file,"%i",&dau[idau]);
                     }
                     // add decay channel

                     part->AddDecayChannel(decay_type,branching_ratio,ndau,dau);
                     ich++;
                  }
                  // skip end of line
                  fgets(c,200,file);
               }
            }
         }
      } else {
         // skip end of line
         fgets(c,200,file);
      }
   }
   // in the end loop over the antiparticles and
   // define their decay lists
   TIter it(fParticleList);

   Int_t code[20];
   TParticlePDG  *ap, *p, *daughter;
   TDecayChannel *dc;

   while ((p = (TParticlePDG*) it.Next())) {

      // define decay channels for antiparticles
      if (p->PdgCode() < 0) {
         ap = GetParticle(-p->PdgCode());
         nch = ap->NDecayChannels();
         for (ich=0; ich<nch; ich++) {
            dc = ap->DecayChannel(ich);
            ndau = dc->NDaughters();
            for (int i=0; i<ndau; i++) {
               // conserve CPT

               code[i] = dc->DaughterPdgCode(i);
               daughter = GetParticle(code[i]);
               if (daughter->AntiParticle()) {
                  // this particle does have an
                  // antiparticle
                  code[i] = -code[i];
               }
            }
            p->AddDecayChannel(dc->MatrixElementCode(),
                               dc->BranchingRatio(),
                               dc->NDaughters(),
                               code);
         }
         p->SetAntiParticle(ap);
         ap->SetAntiParticle(p);
      }
   }

   fclose(file);
   return;
}


//______________________________________________________________________________
void TDatabasePDG::Browse(TBrowser* b)
{
   //browse data base
   if (fListOfClasses ) fListOfClasses->Browse(b);
}


//______________________________________________________________________________
Int_t TDatabasePDG::WritePDGTable(const char *filename)
{
   // write contents of the particle DB into a file

   if (fParticleList == 0) {
      Error("WritePDGTable","Do not have a valid PDG particle list;"
                            " consider loading it with ReadPDGTable first.");
      return -1;
   }

   FILE *file = fopen(filename,"w");
   if (file == 0) {
      Error("WritePDGTable","Could not open PDG particle file %s",filename);
      return -1;
   }

   fprintf(file,"#--------------------------------------------------------------------\n");
   fprintf(file,"#    i   NAME.............  KF AP   CLASS      Q        MASS     WIDTH  2*I+1 I3 2*S+1 FLVR TrkCod N(dec)\n");
   fprintf(file,"#--------------------------------------------------------------------\n");

   Int_t nparts=fParticleList->GetEntries();
   for(Int_t i=0;i<nparts;++i) {
      TParticlePDG *p = dynamic_cast<TParticlePDG*>(fParticleList->At(i));
      if(!p) continue;

      Int_t ich=i+1;
      Int_t kf=p->PdgCode();
      fprintf(file,"%5i %-20s %- 6i ", ich, p->GetName(), kf);

      Int_t anti=p->AntiParticle() ? 1:0;
      if(kf<0) {
         for(Int_t j=0;j<nparts;++j) {
            TParticlePDG *dummy = dynamic_cast<TParticlePDG*>(fParticleList->At(j));
            if(dummy==p->AntiParticle()) {
               anti=j+1;
               break;
            }
         }
         fprintf(file,"%i 0\n",anti);
         continue;
      }

      fprintf(file,"%i ",anti);
      fprintf(file,"%i ",100);
      fprintf(file,"%s ",p->ParticleClass());
      fprintf(file,"% i ",(Int_t)p->Charge());
      fprintf(file,"%.5le ",p->Mass());
      fprintf(file,"%.5le ",p->Width());
      fprintf(file,"%i ",(Int_t)p->Isospin());
      fprintf(file,"%i ",(Int_t)p->I3());
      fprintf(file,"%i ",(Int_t)p->Spin());
      fprintf(file,"%i ",-1);
      fprintf(file,"%i ",p->TrackingCode());
      Int_t nch=p->NDecayChannels();
      fprintf(file,"%i\n",nch);
      if(nch==0) {
         continue;
      }
      fprintf(file,"#----------------------------------------------------------------------\n");
      fprintf(file,"#    decay  type(PY6)    BR     Nd         daughters(codes, then names)\n");
      fprintf(file,"#----------------------------------------------------------------------\n");
      for(Int_t j=0;j<nch;++j) {
         TDecayChannel *dc=p->DecayChannel(j);

         fprintf(file,"%9i   ",dc->Number()+1);
         fprintf(file,"%3i   ",dc->MatrixElementCode());
         fprintf(file,"%.5le  ",dc->BranchingRatio());
         Int_t ndau=dc->NDaughters();
         fprintf(file,"%3i       ",ndau);
         for (int idau=0; idau<ndau; idau++) {
            fprintf(file,"%- 6i ",dc->DaughterPdgCode(idau));
         }
         for (int idau=0; idau<ndau; idau++) {
            TParticlePDG *dummy=GetParticle(dc->DaughterPdgCode(idau));
            if(dummy)
               fprintf(file,"%-10s ",dummy->GetName());
            else
               fprintf(file,"%-10s ","???");
         }
         fprintf(file,"\n");
      }
   }

   return nparts;
}
 TDatabasePDG.cxx:1
 TDatabasePDG.cxx:2
 TDatabasePDG.cxx:3
 TDatabasePDG.cxx:4
 TDatabasePDG.cxx:5
 TDatabasePDG.cxx:6
 TDatabasePDG.cxx:7
 TDatabasePDG.cxx:8
 TDatabasePDG.cxx:9
 TDatabasePDG.cxx:10
 TDatabasePDG.cxx:11
 TDatabasePDG.cxx:12
 TDatabasePDG.cxx:13
 TDatabasePDG.cxx:14
 TDatabasePDG.cxx:15
 TDatabasePDG.cxx:16
 TDatabasePDG.cxx:17
 TDatabasePDG.cxx:18
 TDatabasePDG.cxx:19
 TDatabasePDG.cxx:20
 TDatabasePDG.cxx:21
 TDatabasePDG.cxx:22
 TDatabasePDG.cxx:23
 TDatabasePDG.cxx:24
 TDatabasePDG.cxx:25
 TDatabasePDG.cxx:26
 TDatabasePDG.cxx:27
 TDatabasePDG.cxx:28
 TDatabasePDG.cxx:29
 TDatabasePDG.cxx:30
 TDatabasePDG.cxx:31
 TDatabasePDG.cxx:32
 TDatabasePDG.cxx:33
 TDatabasePDG.cxx:34
 TDatabasePDG.cxx:35
 TDatabasePDG.cxx:36
 TDatabasePDG.cxx:37
 TDatabasePDG.cxx:38
 TDatabasePDG.cxx:39
 TDatabasePDG.cxx:40
 TDatabasePDG.cxx:41
 TDatabasePDG.cxx:42
 TDatabasePDG.cxx:43
 TDatabasePDG.cxx:44
 TDatabasePDG.cxx:45
 TDatabasePDG.cxx:46
 TDatabasePDG.cxx:47
 TDatabasePDG.cxx:48
 TDatabasePDG.cxx:49
 TDatabasePDG.cxx:50
 TDatabasePDG.cxx:51
 TDatabasePDG.cxx:52
 TDatabasePDG.cxx:53
 TDatabasePDG.cxx:54
 TDatabasePDG.cxx:55
 TDatabasePDG.cxx:56
 TDatabasePDG.cxx:57
 TDatabasePDG.cxx:58
 TDatabasePDG.cxx:59
 TDatabasePDG.cxx:60
 TDatabasePDG.cxx:61
 TDatabasePDG.cxx:62
 TDatabasePDG.cxx:63
 TDatabasePDG.cxx:64
 TDatabasePDG.cxx:65
 TDatabasePDG.cxx:66
 TDatabasePDG.cxx:67
 TDatabasePDG.cxx:68
 TDatabasePDG.cxx:69
 TDatabasePDG.cxx:70
 TDatabasePDG.cxx:71
 TDatabasePDG.cxx:72
 TDatabasePDG.cxx:73
 TDatabasePDG.cxx:74
 TDatabasePDG.cxx:75
 TDatabasePDG.cxx:76
 TDatabasePDG.cxx:77
 TDatabasePDG.cxx:78
 TDatabasePDG.cxx:79
 TDatabasePDG.cxx:80
 TDatabasePDG.cxx:81
 TDatabasePDG.cxx:82
 TDatabasePDG.cxx:83
 TDatabasePDG.cxx:84
 TDatabasePDG.cxx:85
 TDatabasePDG.cxx:86
 TDatabasePDG.cxx:87
 TDatabasePDG.cxx:88
 TDatabasePDG.cxx:89
 TDatabasePDG.cxx:90
 TDatabasePDG.cxx:91
 TDatabasePDG.cxx:92
 TDatabasePDG.cxx:93
 TDatabasePDG.cxx:94
 TDatabasePDG.cxx:95
 TDatabasePDG.cxx:96
 TDatabasePDG.cxx:97
 TDatabasePDG.cxx:98
 TDatabasePDG.cxx:99
 TDatabasePDG.cxx:100
 TDatabasePDG.cxx:101
 TDatabasePDG.cxx:102
 TDatabasePDG.cxx:103
 TDatabasePDG.cxx:104
 TDatabasePDG.cxx:105
 TDatabasePDG.cxx:106
 TDatabasePDG.cxx:107
 TDatabasePDG.cxx:108
 TDatabasePDG.cxx:109
 TDatabasePDG.cxx:110
 TDatabasePDG.cxx:111
 TDatabasePDG.cxx:112
 TDatabasePDG.cxx:113
 TDatabasePDG.cxx:114
 TDatabasePDG.cxx:115
 TDatabasePDG.cxx:116
 TDatabasePDG.cxx:117
 TDatabasePDG.cxx:118
 TDatabasePDG.cxx:119
 TDatabasePDG.cxx:120
 TDatabasePDG.cxx:121
 TDatabasePDG.cxx:122
 TDatabasePDG.cxx:123
 TDatabasePDG.cxx:124
 TDatabasePDG.cxx:125
 TDatabasePDG.cxx:126
 TDatabasePDG.cxx:127
 TDatabasePDG.cxx:128
 TDatabasePDG.cxx:129
 TDatabasePDG.cxx:130
 TDatabasePDG.cxx:131
 TDatabasePDG.cxx:132
 TDatabasePDG.cxx:133
 TDatabasePDG.cxx:134
 TDatabasePDG.cxx:135
 TDatabasePDG.cxx:136
 TDatabasePDG.cxx:137
 TDatabasePDG.cxx:138
 TDatabasePDG.cxx:139
 TDatabasePDG.cxx:140
 TDatabasePDG.cxx:141
 TDatabasePDG.cxx:142
 TDatabasePDG.cxx:143
 TDatabasePDG.cxx:144
 TDatabasePDG.cxx:145
 TDatabasePDG.cxx:146
 TDatabasePDG.cxx:147
 TDatabasePDG.cxx:148
 TDatabasePDG.cxx:149
 TDatabasePDG.cxx:150
 TDatabasePDG.cxx:151
 TDatabasePDG.cxx:152
 TDatabasePDG.cxx:153
 TDatabasePDG.cxx:154
 TDatabasePDG.cxx:155
 TDatabasePDG.cxx:156
 TDatabasePDG.cxx:157
 TDatabasePDG.cxx:158
 TDatabasePDG.cxx:159
 TDatabasePDG.cxx:160
 TDatabasePDG.cxx:161
 TDatabasePDG.cxx:162
 TDatabasePDG.cxx:163
 TDatabasePDG.cxx:164
 TDatabasePDG.cxx:165
 TDatabasePDG.cxx:166
 TDatabasePDG.cxx:167
 TDatabasePDG.cxx:168
 TDatabasePDG.cxx:169
 TDatabasePDG.cxx:170
 TDatabasePDG.cxx:171
 TDatabasePDG.cxx:172
 TDatabasePDG.cxx:173
 TDatabasePDG.cxx:174
 TDatabasePDG.cxx:175
 TDatabasePDG.cxx:176
 TDatabasePDG.cxx:177
 TDatabasePDG.cxx:178
 TDatabasePDG.cxx:179
 TDatabasePDG.cxx:180
 TDatabasePDG.cxx:181
 TDatabasePDG.cxx:182
 TDatabasePDG.cxx:183
 TDatabasePDG.cxx:184
 TDatabasePDG.cxx:185
 TDatabasePDG.cxx:186
 TDatabasePDG.cxx:187
 TDatabasePDG.cxx:188
 TDatabasePDG.cxx:189
 TDatabasePDG.cxx:190
 TDatabasePDG.cxx:191
 TDatabasePDG.cxx:192
 TDatabasePDG.cxx:193
 TDatabasePDG.cxx:194
 TDatabasePDG.cxx:195
 TDatabasePDG.cxx:196
 TDatabasePDG.cxx:197
 TDatabasePDG.cxx:198
 TDatabasePDG.cxx:199
 TDatabasePDG.cxx:200
 TDatabasePDG.cxx:201
 TDatabasePDG.cxx:202
 TDatabasePDG.cxx:203
 TDatabasePDG.cxx:204
 TDatabasePDG.cxx:205
 TDatabasePDG.cxx:206
 TDatabasePDG.cxx:207
 TDatabasePDG.cxx:208
 TDatabasePDG.cxx:209
 TDatabasePDG.cxx:210
 TDatabasePDG.cxx:211
 TDatabasePDG.cxx:212
 TDatabasePDG.cxx:213
 TDatabasePDG.cxx:214
 TDatabasePDG.cxx:215
 TDatabasePDG.cxx:216
 TDatabasePDG.cxx:217
 TDatabasePDG.cxx:218
 TDatabasePDG.cxx:219
 TDatabasePDG.cxx:220
 TDatabasePDG.cxx:221
 TDatabasePDG.cxx:222
 TDatabasePDG.cxx:223
 TDatabasePDG.cxx:224
 TDatabasePDG.cxx:225
 TDatabasePDG.cxx:226
 TDatabasePDG.cxx:227
 TDatabasePDG.cxx:228
 TDatabasePDG.cxx:229
 TDatabasePDG.cxx:230
 TDatabasePDG.cxx:231
 TDatabasePDG.cxx:232
 TDatabasePDG.cxx:233
 TDatabasePDG.cxx:234
 TDatabasePDG.cxx:235
 TDatabasePDG.cxx:236
 TDatabasePDG.cxx:237
 TDatabasePDG.cxx:238
 TDatabasePDG.cxx:239
 TDatabasePDG.cxx:240
 TDatabasePDG.cxx:241
 TDatabasePDG.cxx:242
 TDatabasePDG.cxx:243
 TDatabasePDG.cxx:244
 TDatabasePDG.cxx:245
 TDatabasePDG.cxx:246
 TDatabasePDG.cxx:247
 TDatabasePDG.cxx:248
 TDatabasePDG.cxx:249
 TDatabasePDG.cxx:250
 TDatabasePDG.cxx:251
 TDatabasePDG.cxx:252
 TDatabasePDG.cxx:253
 TDatabasePDG.cxx:254
 TDatabasePDG.cxx:255
 TDatabasePDG.cxx:256
 TDatabasePDG.cxx:257
 TDatabasePDG.cxx:258
 TDatabasePDG.cxx:259
 TDatabasePDG.cxx:260
 TDatabasePDG.cxx:261
 TDatabasePDG.cxx:262
 TDatabasePDG.cxx:263
 TDatabasePDG.cxx:264
 TDatabasePDG.cxx:265
 TDatabasePDG.cxx:266
 TDatabasePDG.cxx:267
 TDatabasePDG.cxx:268
 TDatabasePDG.cxx:269
 TDatabasePDG.cxx:270
 TDatabasePDG.cxx:271
 TDatabasePDG.cxx:272
 TDatabasePDG.cxx:273
 TDatabasePDG.cxx:274
 TDatabasePDG.cxx:275
 TDatabasePDG.cxx:276
 TDatabasePDG.cxx:277
 TDatabasePDG.cxx:278
 TDatabasePDG.cxx:279
 TDatabasePDG.cxx:280
 TDatabasePDG.cxx:281
 TDatabasePDG.cxx:282
 TDatabasePDG.cxx:283
 TDatabasePDG.cxx:284
 TDatabasePDG.cxx:285
 TDatabasePDG.cxx:286
 TDatabasePDG.cxx:287
 TDatabasePDG.cxx:288
 TDatabasePDG.cxx:289
 TDatabasePDG.cxx:290
 TDatabasePDG.cxx:291
 TDatabasePDG.cxx:292
 TDatabasePDG.cxx:293
 TDatabasePDG.cxx:294
 TDatabasePDG.cxx:295
 TDatabasePDG.cxx:296
 TDatabasePDG.cxx:297
 TDatabasePDG.cxx:298
 TDatabasePDG.cxx:299
 TDatabasePDG.cxx:300
 TDatabasePDG.cxx:301
 TDatabasePDG.cxx:302
 TDatabasePDG.cxx:303
 TDatabasePDG.cxx:304
 TDatabasePDG.cxx:305
 TDatabasePDG.cxx:306
 TDatabasePDG.cxx:307
 TDatabasePDG.cxx:308
 TDatabasePDG.cxx:309
 TDatabasePDG.cxx:310
 TDatabasePDG.cxx:311
 TDatabasePDG.cxx:312
 TDatabasePDG.cxx:313
 TDatabasePDG.cxx:314
 TDatabasePDG.cxx:315
 TDatabasePDG.cxx:316
 TDatabasePDG.cxx:317
 TDatabasePDG.cxx:318
 TDatabasePDG.cxx:319
 TDatabasePDG.cxx:320
 TDatabasePDG.cxx:321
 TDatabasePDG.cxx:322
 TDatabasePDG.cxx:323
 TDatabasePDG.cxx:324
 TDatabasePDG.cxx:325
 TDatabasePDG.cxx:326
 TDatabasePDG.cxx:327
 TDatabasePDG.cxx:328
 TDatabasePDG.cxx:329
 TDatabasePDG.cxx:330
 TDatabasePDG.cxx:331
 TDatabasePDG.cxx:332
 TDatabasePDG.cxx:333
 TDatabasePDG.cxx:334
 TDatabasePDG.cxx:335
 TDatabasePDG.cxx:336
 TDatabasePDG.cxx:337
 TDatabasePDG.cxx:338
 TDatabasePDG.cxx:339
 TDatabasePDG.cxx:340
 TDatabasePDG.cxx:341
 TDatabasePDG.cxx:342
 TDatabasePDG.cxx:343
 TDatabasePDG.cxx:344
 TDatabasePDG.cxx:345
 TDatabasePDG.cxx:346
 TDatabasePDG.cxx:347
 TDatabasePDG.cxx:348
 TDatabasePDG.cxx:349
 TDatabasePDG.cxx:350
 TDatabasePDG.cxx:351
 TDatabasePDG.cxx:352
 TDatabasePDG.cxx:353
 TDatabasePDG.cxx:354
 TDatabasePDG.cxx:355
 TDatabasePDG.cxx:356
 TDatabasePDG.cxx:357
 TDatabasePDG.cxx:358
 TDatabasePDG.cxx:359
 TDatabasePDG.cxx:360
 TDatabasePDG.cxx:361
 TDatabasePDG.cxx:362
 TDatabasePDG.cxx:363
 TDatabasePDG.cxx:364
 TDatabasePDG.cxx:365
 TDatabasePDG.cxx:366
 TDatabasePDG.cxx:367
 TDatabasePDG.cxx:368
 TDatabasePDG.cxx:369
 TDatabasePDG.cxx:370
 TDatabasePDG.cxx:371
 TDatabasePDG.cxx:372
 TDatabasePDG.cxx:373
 TDatabasePDG.cxx:374
 TDatabasePDG.cxx:375
 TDatabasePDG.cxx:376
 TDatabasePDG.cxx:377
 TDatabasePDG.cxx:378
 TDatabasePDG.cxx:379
 TDatabasePDG.cxx:380
 TDatabasePDG.cxx:381
 TDatabasePDG.cxx:382
 TDatabasePDG.cxx:383
 TDatabasePDG.cxx:384
 TDatabasePDG.cxx:385
 TDatabasePDG.cxx:386
 TDatabasePDG.cxx:387
 TDatabasePDG.cxx:388
 TDatabasePDG.cxx:389
 TDatabasePDG.cxx:390
 TDatabasePDG.cxx:391
 TDatabasePDG.cxx:392
 TDatabasePDG.cxx:393
 TDatabasePDG.cxx:394
 TDatabasePDG.cxx:395
 TDatabasePDG.cxx:396
 TDatabasePDG.cxx:397
 TDatabasePDG.cxx:398
 TDatabasePDG.cxx:399
 TDatabasePDG.cxx:400
 TDatabasePDG.cxx:401
 TDatabasePDG.cxx:402
 TDatabasePDG.cxx:403
 TDatabasePDG.cxx:404
 TDatabasePDG.cxx:405
 TDatabasePDG.cxx:406
 TDatabasePDG.cxx:407
 TDatabasePDG.cxx:408
 TDatabasePDG.cxx:409
 TDatabasePDG.cxx:410
 TDatabasePDG.cxx:411
 TDatabasePDG.cxx:412
 TDatabasePDG.cxx:413
 TDatabasePDG.cxx:414
 TDatabasePDG.cxx:415
 TDatabasePDG.cxx:416
 TDatabasePDG.cxx:417
 TDatabasePDG.cxx:418
 TDatabasePDG.cxx:419
 TDatabasePDG.cxx:420
 TDatabasePDG.cxx:421
 TDatabasePDG.cxx:422
 TDatabasePDG.cxx:423
 TDatabasePDG.cxx:424
 TDatabasePDG.cxx:425
 TDatabasePDG.cxx:426
 TDatabasePDG.cxx:427
 TDatabasePDG.cxx:428
 TDatabasePDG.cxx:429
 TDatabasePDG.cxx:430
 TDatabasePDG.cxx:431
 TDatabasePDG.cxx:432
 TDatabasePDG.cxx:433
 TDatabasePDG.cxx:434
 TDatabasePDG.cxx:435
 TDatabasePDG.cxx:436
 TDatabasePDG.cxx:437
 TDatabasePDG.cxx:438
 TDatabasePDG.cxx:439
 TDatabasePDG.cxx:440
 TDatabasePDG.cxx:441
 TDatabasePDG.cxx:442
 TDatabasePDG.cxx:443
 TDatabasePDG.cxx:444
 TDatabasePDG.cxx:445
 TDatabasePDG.cxx:446
 TDatabasePDG.cxx:447
 TDatabasePDG.cxx:448
 TDatabasePDG.cxx:449
 TDatabasePDG.cxx:450
 TDatabasePDG.cxx:451
 TDatabasePDG.cxx:452
 TDatabasePDG.cxx:453
 TDatabasePDG.cxx:454
 TDatabasePDG.cxx:455
 TDatabasePDG.cxx:456
 TDatabasePDG.cxx:457
 TDatabasePDG.cxx:458
 TDatabasePDG.cxx:459
 TDatabasePDG.cxx:460
 TDatabasePDG.cxx:461
 TDatabasePDG.cxx:462
 TDatabasePDG.cxx:463
 TDatabasePDG.cxx:464
 TDatabasePDG.cxx:465
 TDatabasePDG.cxx:466
 TDatabasePDG.cxx:467
 TDatabasePDG.cxx:468
 TDatabasePDG.cxx:469
 TDatabasePDG.cxx:470
 TDatabasePDG.cxx:471
 TDatabasePDG.cxx:472
 TDatabasePDG.cxx:473
 TDatabasePDG.cxx:474
 TDatabasePDG.cxx:475
 TDatabasePDG.cxx:476
 TDatabasePDG.cxx:477
 TDatabasePDG.cxx:478
 TDatabasePDG.cxx:479
 TDatabasePDG.cxx:480
 TDatabasePDG.cxx:481
 TDatabasePDG.cxx:482
 TDatabasePDG.cxx:483
 TDatabasePDG.cxx:484
 TDatabasePDG.cxx:485
 TDatabasePDG.cxx:486
 TDatabasePDG.cxx:487
 TDatabasePDG.cxx:488
 TDatabasePDG.cxx:489
 TDatabasePDG.cxx:490
 TDatabasePDG.cxx:491
 TDatabasePDG.cxx:492
 TDatabasePDG.cxx:493
 TDatabasePDG.cxx:494
 TDatabasePDG.cxx:495
 TDatabasePDG.cxx:496
 TDatabasePDG.cxx:497
 TDatabasePDG.cxx:498
 TDatabasePDG.cxx:499
 TDatabasePDG.cxx:500
 TDatabasePDG.cxx:501
 TDatabasePDG.cxx:502
 TDatabasePDG.cxx:503
 TDatabasePDG.cxx:504
 TDatabasePDG.cxx:505
 TDatabasePDG.cxx:506
 TDatabasePDG.cxx:507
 TDatabasePDG.cxx:508
 TDatabasePDG.cxx:509
 TDatabasePDG.cxx:510
 TDatabasePDG.cxx:511
 TDatabasePDG.cxx:512
 TDatabasePDG.cxx:513
 TDatabasePDG.cxx:514
 TDatabasePDG.cxx:515
 TDatabasePDG.cxx:516
 TDatabasePDG.cxx:517
 TDatabasePDG.cxx:518
 TDatabasePDG.cxx:519
 TDatabasePDG.cxx:520
 TDatabasePDG.cxx:521
 TDatabasePDG.cxx:522
 TDatabasePDG.cxx:523
 TDatabasePDG.cxx:524
 TDatabasePDG.cxx:525
 TDatabasePDG.cxx:526
 TDatabasePDG.cxx:527
 TDatabasePDG.cxx:528
 TDatabasePDG.cxx:529
 TDatabasePDG.cxx:530
 TDatabasePDG.cxx:531
 TDatabasePDG.cxx:532
 TDatabasePDG.cxx:533
 TDatabasePDG.cxx:534
 TDatabasePDG.cxx:535
 TDatabasePDG.cxx:536
 TDatabasePDG.cxx:537
 TDatabasePDG.cxx:538
 TDatabasePDG.cxx:539
 TDatabasePDG.cxx:540
 TDatabasePDG.cxx:541
 TDatabasePDG.cxx:542
 TDatabasePDG.cxx:543
 TDatabasePDG.cxx:544
 TDatabasePDG.cxx:545
 TDatabasePDG.cxx:546
 TDatabasePDG.cxx:547
 TDatabasePDG.cxx:548
 TDatabasePDG.cxx:549
 TDatabasePDG.cxx:550
 TDatabasePDG.cxx:551
 TDatabasePDG.cxx:552
 TDatabasePDG.cxx:553
 TDatabasePDG.cxx:554
 TDatabasePDG.cxx:555
 TDatabasePDG.cxx:556
 TDatabasePDG.cxx:557
 TDatabasePDG.cxx:558
 TDatabasePDG.cxx:559
 TDatabasePDG.cxx:560
 TDatabasePDG.cxx:561
 TDatabasePDG.cxx:562
 TDatabasePDG.cxx:563
 TDatabasePDG.cxx:564
 TDatabasePDG.cxx:565
 TDatabasePDG.cxx:566
 TDatabasePDG.cxx:567
 TDatabasePDG.cxx:568
 TDatabasePDG.cxx:569
 TDatabasePDG.cxx:570
 TDatabasePDG.cxx:571
 TDatabasePDG.cxx:572
 TDatabasePDG.cxx:573
 TDatabasePDG.cxx:574
 TDatabasePDG.cxx:575
 TDatabasePDG.cxx:576
 TDatabasePDG.cxx:577
 TDatabasePDG.cxx:578
 TDatabasePDG.cxx:579
 TDatabasePDG.cxx:580
 TDatabasePDG.cxx:581
 TDatabasePDG.cxx:582
 TDatabasePDG.cxx:583
 TDatabasePDG.cxx:584
 TDatabasePDG.cxx:585
 TDatabasePDG.cxx:586
 TDatabasePDG.cxx:587
 TDatabasePDG.cxx:588
 TDatabasePDG.cxx:589
 TDatabasePDG.cxx:590
 TDatabasePDG.cxx:591
 TDatabasePDG.cxx:592
 TDatabasePDG.cxx:593
 TDatabasePDG.cxx:594
 TDatabasePDG.cxx:595
 TDatabasePDG.cxx:596
 TDatabasePDG.cxx:597
 TDatabasePDG.cxx:598
 TDatabasePDG.cxx:599
 TDatabasePDG.cxx:600
 TDatabasePDG.cxx:601
 TDatabasePDG.cxx:602
 TDatabasePDG.cxx:603
 TDatabasePDG.cxx:604
 TDatabasePDG.cxx:605
 TDatabasePDG.cxx:606
 TDatabasePDG.cxx:607
 TDatabasePDG.cxx:608
 TDatabasePDG.cxx:609
 TDatabasePDG.cxx:610
 TDatabasePDG.cxx:611
 TDatabasePDG.cxx:612
 TDatabasePDG.cxx:613
 TDatabasePDG.cxx:614
 TDatabasePDG.cxx:615
 TDatabasePDG.cxx:616
 TDatabasePDG.cxx:617
 TDatabasePDG.cxx:618
 TDatabasePDG.cxx:619
 TDatabasePDG.cxx:620
 TDatabasePDG.cxx:621
 TDatabasePDG.cxx:622
 TDatabasePDG.cxx:623
 TDatabasePDG.cxx:624
 TDatabasePDG.cxx:625
 TDatabasePDG.cxx:626
 TDatabasePDG.cxx:627
 TDatabasePDG.cxx:628
 TDatabasePDG.cxx:629
 TDatabasePDG.cxx:630
 TDatabasePDG.cxx:631
 TDatabasePDG.cxx:632
 TDatabasePDG.cxx:633
 TDatabasePDG.cxx:634
 TDatabasePDG.cxx:635
 TDatabasePDG.cxx:636
 TDatabasePDG.cxx:637
 TDatabasePDG.cxx:638
 TDatabasePDG.cxx:639
 TDatabasePDG.cxx:640
 TDatabasePDG.cxx:641
 TDatabasePDG.cxx:642
 TDatabasePDG.cxx:643
 TDatabasePDG.cxx:644
 TDatabasePDG.cxx:645
 TDatabasePDG.cxx:646
 TDatabasePDG.cxx:647
 TDatabasePDG.cxx:648
 TDatabasePDG.cxx:649
 TDatabasePDG.cxx:650
 TDatabasePDG.cxx:651
 TDatabasePDG.cxx:652
 TDatabasePDG.cxx:653
 TDatabasePDG.cxx:654
 TDatabasePDG.cxx:655
 TDatabasePDG.cxx:656
 TDatabasePDG.cxx:657
 TDatabasePDG.cxx:658
 TDatabasePDG.cxx:659
 TDatabasePDG.cxx:660
 TDatabasePDG.cxx:661
 TDatabasePDG.cxx:662
 TDatabasePDG.cxx:663
 TDatabasePDG.cxx:664
 TDatabasePDG.cxx:665
 TDatabasePDG.cxx:666
 TDatabasePDG.cxx:667
 TDatabasePDG.cxx:668
 TDatabasePDG.cxx:669
 TDatabasePDG.cxx:670
 TDatabasePDG.cxx:671
 TDatabasePDG.cxx:672
 TDatabasePDG.cxx:673
 TDatabasePDG.cxx:674
 TDatabasePDG.cxx:675
 TDatabasePDG.cxx:676
 TDatabasePDG.cxx:677
 TDatabasePDG.cxx:678
 TDatabasePDG.cxx:679
 TDatabasePDG.cxx:680
 TDatabasePDG.cxx:681
 TDatabasePDG.cxx:682
 TDatabasePDG.cxx:683
 TDatabasePDG.cxx:684
 TDatabasePDG.cxx:685
 TDatabasePDG.cxx:686
 TDatabasePDG.cxx:687
 TDatabasePDG.cxx:688
 TDatabasePDG.cxx:689
 TDatabasePDG.cxx:690
 TDatabasePDG.cxx:691
 TDatabasePDG.cxx:692
 TDatabasePDG.cxx:693
 TDatabasePDG.cxx:694
 TDatabasePDG.cxx:695
 TDatabasePDG.cxx:696
 TDatabasePDG.cxx:697
 TDatabasePDG.cxx:698
 TDatabasePDG.cxx:699
 TDatabasePDG.cxx:700
 TDatabasePDG.cxx:701
 TDatabasePDG.cxx:702
 TDatabasePDG.cxx:703
 TDatabasePDG.cxx:704
 TDatabasePDG.cxx:705
 TDatabasePDG.cxx:706
 TDatabasePDG.cxx:707
 TDatabasePDG.cxx:708
 TDatabasePDG.cxx:709
 TDatabasePDG.cxx:710
 TDatabasePDG.cxx:711
 TDatabasePDG.cxx:712
 TDatabasePDG.cxx:713
 TDatabasePDG.cxx:714
 TDatabasePDG.cxx:715
 TDatabasePDG.cxx:716
 TDatabasePDG.cxx:717
 TDatabasePDG.cxx:718
 TDatabasePDG.cxx:719
 TDatabasePDG.cxx:720
 TDatabasePDG.cxx:721
 TDatabasePDG.cxx:722
 TDatabasePDG.cxx:723
 TDatabasePDG.cxx:724
 TDatabasePDG.cxx:725
 TDatabasePDG.cxx:726
 TDatabasePDG.cxx:727
 TDatabasePDG.cxx:728
 TDatabasePDG.cxx:729
 TDatabasePDG.cxx:730
 TDatabasePDG.cxx:731
 TDatabasePDG.cxx:732
 TDatabasePDG.cxx:733
 TDatabasePDG.cxx:734
 TDatabasePDG.cxx:735
 TDatabasePDG.cxx:736
 TDatabasePDG.cxx:737
 TDatabasePDG.cxx:738
 TDatabasePDG.cxx:739
 TDatabasePDG.cxx:740
 TDatabasePDG.cxx:741
 TDatabasePDG.cxx:742
 TDatabasePDG.cxx:743
 TDatabasePDG.cxx:744
 TDatabasePDG.cxx:745
 TDatabasePDG.cxx:746
 TDatabasePDG.cxx:747
 TDatabasePDG.cxx:748
 TDatabasePDG.cxx:749
 TDatabasePDG.cxx:750
 TDatabasePDG.cxx:751
 TDatabasePDG.cxx:752
 TDatabasePDG.cxx:753
 TDatabasePDG.cxx:754
 TDatabasePDG.cxx:755
 TDatabasePDG.cxx:756
 TDatabasePDG.cxx:757
 TDatabasePDG.cxx:758
 TDatabasePDG.cxx:759
 TDatabasePDG.cxx:760
 TDatabasePDG.cxx:761
 TDatabasePDG.cxx:762
 TDatabasePDG.cxx:763
 TDatabasePDG.cxx:764
 TDatabasePDG.cxx:765
 TDatabasePDG.cxx:766
 TDatabasePDG.cxx:767
 TDatabasePDG.cxx:768
 TDatabasePDG.cxx:769
 TDatabasePDG.cxx:770
 TDatabasePDG.cxx:771
 TDatabasePDG.cxx:772
 TDatabasePDG.cxx:773
 TDatabasePDG.cxx:774