ROOT logo
// @(#)root/geom:$Id: TGeoElement.h 21425 2007-12-17 15:59:27Z brun $
// Author: Andrei Gheata   17/06/04
// Added support for radionuclides: Mihaela Gheata 24/08/2006
/*************************************************************************
 * 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.             *
 *************************************************************************/

#ifndef ROOT_TGeoElement
#define ROOT_TGeoElement

#ifndef ROOT_TNamed
#include "TNamed.h"
#endif

#ifndef ROOT_TAttLine
#include "TAttLine.h"
#endif

#ifndef ROOT_TAttFill
#include "TAttFill.h"
#endif

#ifndef ROOT_TAttMarker
#include "TAttMarker.h"
#endif

#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif

#include <map>

class TGeoElementTable;

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoElement - a chemical element                                       //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoElement : public TNamed
{
protected:
   enum EGeoElement {
      kElemUsed    =   BIT(17),
      kElemDefined =   BIT(18),
      kElementChecked = BIT(19)
   };

   Int_t                    fZ;          // Z of material
   Double_t                 fA;          // A of material

public:
   // constructors
   TGeoElement();
   TGeoElement(const char *name, const char *title, Int_t z, Double_t a);
   // destructor
   virtual ~TGeoElement()             {;}
   // methods
   virtual Int_t            ENDFCode()    const { return 0;}
   Int_t                    Z() const {return fZ;}
   Double_t                 A() const {return fA;}
   Bool_t                   IsDefined() const {return TObject::TestBit(kElemDefined);}   
   virtual Bool_t           IsRadioNuclide() const {return kFALSE;}
   Bool_t                   IsUsed() const {return TObject::TestBit(kElemUsed);}
   void                     SetDefined(Bool_t flag=kTRUE) {TObject::SetBit(kElemDefined,flag);}                    
   void                     SetUsed(Bool_t flag=kTRUE) {TObject::SetBit(kElemUsed,flag);}                    
   TGeoElementTable        *GetElementTable() const;
   

   ClassDef(TGeoElement, 1)              // base element class
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoElementRN - a radionuclide.                                        //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoDecayChannel;
class TGeoBatemanSol;

class TGeoElementRN : public TGeoElement
{
protected:
   Int_t                    fENDFcode; // ENDF element code
   Int_t                    fIso;      // Isomer number
   Double_t                 fLevel;    // Isomeric level
   Double_t                 fDeltaM;   // Mass excess
   Double_t                 fHalfLife; // Half life
   Double_t                 fNatAbun;  // Natural Abundance
//   char                     fJP[11];   // Spin-parity
   Double_t                 fTH_F;     // Hynalation toxicity
   Double_t                 fTG_F;     // Ingestion toxicity
   Double_t                 fTH_S;     // Hynalation toxicity
   Double_t                 fTG_S;     // Ingestion toxicity
   Int_t                    fStatus;   // Status code
   TGeoBatemanSol          *fRatio;    // Time evolution of proportion by number

   TObjArray               *fDecays;   // List of decay modes
   
   void                     MakeName(Int_t a, Int_t z, Int_t iso);

   TGeoElementRN(const TGeoElementRN& elem); 
   TGeoElementRN& operator=(const TGeoElementRN& elem); 
public:
   TGeoElementRN();
   TGeoElementRN(Int_t A, Int_t Z, Int_t iso, Double_t level, 
         Double_t deltaM, Double_t halfLife, const char* JP,
         Double_t natAbun, Double_t th_f, Double_t tg_f, Double_t th_s,
         Double_t tg_s, Int_t status); 
   virtual ~TGeoElementRN();

   void                     AddDecay(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue);
   void                     AddDecay(TGeoDecayChannel *dc);
   void                     AddRatio(TGeoBatemanSol &ratio);
   void                     ResetRatio();
   static Int_t             ENDF(Int_t a, Int_t z, Int_t iso) {return 10000*z+10*a+iso;}

   // Getters
   virtual Int_t            ENDFCode()    const {return fENDFcode;}
   virtual Bool_t           IsRadioNuclide() const {return kTRUE;}
   Int_t                    MassNo()      const {return (Int_t)fA;}
   Int_t                    AtomicNo()    const {return fZ;}
   Int_t                    IsoNo()       const {return fIso;}
   Double_t                 Level()       const {return fLevel;}    
   Double_t                 MassEx()      const {return fDeltaM;}   
   Double_t                 HalfLife()    const {return fHalfLife;}
   Double_t                 NatAbun()     const {return fNatAbun;}  
   const char*              PJ()          const {return fTitle.Data();}   
   Double_t                 TH_F()        const {return fTH_F;}     
   Double_t                 TG_F()        const {return fTG_F;}     
   Double_t                 TH_S()        const {return fTH_S;}     
   Double_t                 TG_S()        const {return fTG_S;}     
   Double_t                 Status()      const {return fStatus;}
   Bool_t                   Stable()      const {return !fDecays;}
   TObjArray               *Decays()      const {return fDecays;}
   Int_t                    GetNdecays()  const;
   TGeoBatemanSol          *Ratio()       const {return fRatio;}

   // Utilities
   Bool_t                   CheckDecays() const;
   Int_t                    DecayResult(TGeoDecayChannel *dc) const;
   void                     FillPopulation(TObjArray *population, Double_t precision=0.001, Double_t factor=1.);
   virtual void             Print(Option_t *option = "") const;
   static TGeoElementRN    *ReadElementRN(const char *record, Int_t &ndecays);
   virtual void             SavePrimitive(ostream &out, Option_t *option = "");
  
   ClassDef(TGeoElementRN, 2)           // radionuclides class
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoDecayChannel - decay channel utility class.                        //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoDecayChannel : public TObject
{
private:
   UInt_t                   fDecay;          // Decay mode
   Int_t                    fDiso;           // Delta isomeric number
   Double_t                 fBranchingRatio; // Branching Ratio
   Double_t                 fQvalue;         // Qvalue in GeV
   TGeoElementRN           *fParent;         // Parent element
   TGeoElementRN           *fDaughter;       // Daughter element
public:
   enum ENuclearDecayMode {
      kBitMask32  = 0xffffffff,
      k2BetaMinus   = BIT(0),
      kBetaMinus    = BIT(1),
      kNeutronEm    = BIT(2), 
      kProtonEm     = BIT(3),
      kAlpha        = BIT(4),
      kECF          = BIT(5),
      kElecCapt     = BIT(6),
      kIsoTrans     = BIT(7),
      kI            = BIT(8),
      kSpontFiss    = BIT(9),
      k2P           = BIT(10),
      k2N           = BIT(11),
      k2A           = BIT(12),
      kCarbon12     = BIT(13),
      kCarbon14     = BIT(14)
   };
   TGeoDecayChannel() : fDecay(0), fDiso(0), fBranchingRatio(0), fQvalue(0), fParent(0), fDaughter(0) {}
   TGeoDecayChannel(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue)
                  : fDecay(decay), fDiso(diso), fBranchingRatio(branchingRatio), fQvalue(qValue), fParent(0), fDaughter(0) {}
   TGeoDecayChannel(const TGeoDecayChannel &dc) : TObject(dc),fDecay(dc.fDecay),fDiso(dc.fDiso),fBranchingRatio(dc.fBranchingRatio),
                                                  fQvalue(dc.fQvalue),fParent(dc.fParent),fDaughter(dc.fDaughter) {}
   virtual ~TGeoDecayChannel() {}

   TGeoDecayChannel& operator=(const TGeoDecayChannel& dc);

   // Getters
   Int_t                    GetIndex()       const;
   virtual const char      *GetName()        const;
   UInt_t                   Decay()          const {return fDecay;}
   Double_t                 BranchingRatio() const {return fBranchingRatio;}
   Double_t                 Qvalue()         const {return fQvalue;}
   Int_t                    DeltaIso()       const {return fDiso;}
   TGeoElementRN           *Daughter()       const {return fDaughter;}
   TGeoElementRN           *Parent()         const {return fParent;}
   static void              DecayName(UInt_t decay, TString &name);
   // Setters
   void                     SetParent(TGeoElementRN *parent) {fParent = parent;}
   void                     SetDaughter(TGeoElementRN *daughter) {fDaughter = daughter;}
   // Services
   virtual void             Print(Option_t *opt = " ") const;
   static TGeoDecayChannel *ReadDecay(const char *record);
   virtual void             SavePrimitive(ostream &out, Option_t *option = "");
   virtual void             DecayShift(Int_t &dA, Int_t &dZ, Int_t &dI) const ;

   ClassDef(TGeoDecayChannel,1)    // Decay channel for Elements
};

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// TGeoBatemanSol -Class representing the Bateman solution for a decay branch //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

class TGeoBatemanSol : public TObject, public TAttLine, public TAttFill, public TAttMarker
{
private:
   typedef struct {
      Double_t   cn;     // Concentration for element 'i': Ni/Ntop
      Double_t   lambda; // Decay coef. for element 'i'
   } BtCoef_t;     
   TGeoElementRN           *fElem;            // Referred RN element
   TGeoElementRN           *fElemTop;         // Top RN element
   Int_t                    fCsize;           // Size of the array of coefficients
   Int_t                    fNcoeff;          // Number of coefficients
   Double_t                 fFactor;          // Constant factor that applies to all coefficients
   Double_t                 fTmin;            // Minimum value of the time interval
   Double_t                 fTmax;            // Maximum value of the time interval
   BtCoef_t                *fCoeff;           //[fNcoeff] Array of coefficients
public:
   TGeoBatemanSol() : TObject(), TAttLine(), TAttFill(), TAttMarker(), fElem(NULL), fElemTop(NULL), fCsize(0), fNcoeff(0), fFactor(1.), fTmin(0.), fTmax(0), fCoeff(NULL) {}
   TGeoBatemanSol(TGeoElementRN *elem);
   TGeoBatemanSol(const TObjArray *chain);
   TGeoBatemanSol(const TGeoBatemanSol& other);
   ~TGeoBatemanSol();

   TGeoBatemanSol& operator=(const TGeoBatemanSol& other);
   TGeoBatemanSol& operator+=(const TGeoBatemanSol& other);
   
   Double_t                 Concentration(Double_t time) const;
   virtual void             Draw(Option_t *option="");
   void                     GetCoeff(Int_t i, Double_t &cn, Double_t &lambda) const {cn=fCoeff[i].cn; lambda=fCoeff[i].lambda;}
   void                     GetRange(Double_t &tmin, Double_t &tmax) const {tmin=fTmin; tmax=fTmax;}
   TGeoElementRN           *GetElement()    const {return fElem;}
   TGeoElementRN           *GetTopElement() const {return fElemTop;}
   Int_t                    GetNcoeff()     const  {return fNcoeff;}
   virtual void             Print(Option_t *option = "") const;
   void                     SetRange(Double_t tmin=0., Double_t tmax=0.) {fTmin=tmin; fTmax=tmax;}
   void                     SetFactor(Double_t factor) {fFactor = factor;}
   void                     FindSolution(const TObjArray *array);
   void                     Normalize(Double_t factor);

   ClassDef(TGeoBatemanSol,1)       // Solution for the Bateman equation
};   
   
////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoElemIter - iterator for decay chains.                              //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoElemIter
{
private:
   const TGeoElementRN     *fTop;            // Top element of the iteration
   const TGeoElementRN     *fElem;           // Current element
   TObjArray               *fBranch;         // Current branch
   Int_t                    fLevel;          // Current level
   Double_t                 fLimitRatio;     // Minimum cumulative branching ratio
   Double_t                 fRatio;          // Current ratio

protected:
   TGeoElemIter() : fTop(0), fElem(0), fBranch(0), fLevel(0), fLimitRatio(0), fRatio(0) {}
   TGeoElementRN           *Down(Int_t ibranch);
   TGeoElementRN           *Up();

public:
   TGeoElemIter(TGeoElementRN *top, Double_t limit=1.e-4);
   TGeoElemIter(const TGeoElemIter &iter); 
   virtual ~TGeoElemIter();
   
   TGeoElemIter   &operator=(const TGeoElemIter &iter);
   TGeoElementRN  *operator()();
   TGeoElementRN           *Next();

   TObjArray               *GetBranch() const              {return fBranch;}
   const TGeoElementRN     *GetTop() const                 {return fTop;}
   const TGeoElementRN     *GetElement() const             {return fElem;}
   Int_t                    GetLevel() const               {return fLevel;}
   Double_t                 GetRatio() const               {return fRatio;}
   virtual void             Print(Option_t *option="") const;
   void                     SetLimitRatio(Double_t limit)  {fLimitRatio = limit;}
   
   ClassDef(TGeoElemIter,0)    // Iterator for radionuclide chains.
};

////////////////////////////////////////////////////////////////////////////
//                                                                        //
// TGeoElementTable - table of elements                                   //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

class TGeoElementTable : public TObject
{
private:
// data members
   Int_t                    fNelements;    // number of elements
   Int_t                    fNelementsRN;  // number of RN elements
   TObjArray               *fList;         // list of elements
   TObjArray               *fListRN;       // list of RN elements
   // Map of radionuclides
   typedef std::map<Int_t, TGeoElementRN *>   ElementRNMap_t;
   typedef ElementRNMap_t::iterator           ElementRNMapIt_t;
   ElementRNMap_t           fElementsRN; //! map of RN elements with ENDF key

protected:
   TGeoElementTable(const TGeoElementTable&); 
   TGeoElementTable& operator=(const TGeoElementTable&); 

public:
   // constructors
   TGeoElementTable();
   TGeoElementTable(Int_t nelements);
   // destructor
   virtual ~TGeoElementTable();
   // methods

   enum EGeoETStatus {
      kETDefaultElements = BIT(14),
      kETRNElements      = BIT(15)
   };      
   void                     AddElement(const char *name, const char *title, Int_t z, Double_t a);
   void                     AddElementRN(TGeoElementRN *elem);
   void                     BuildDefaultElements();
   void                     ImportElementsRN();
   Bool_t                   CheckTable() const;
   TGeoElement             *FindElement(const char *name);
   TGeoElement             *GetElement(Int_t z) {return (TGeoElement*)fList->At(z);}
   TGeoElementRN           *GetElementRN(Int_t ENDFcode) const;
   TGeoElementRN           *GetElementRN(Int_t a, Int_t z, Int_t iso=0) const;
   TObjArray               *GetElementsRN() const {return fListRN;}
   Bool_t                   HasDefaultElements() const {return TObject::TestBit(kETDefaultElements);}
   Bool_t                   HasRNElements() const {return TObject::TestBit(kETRNElements);}

   Int_t                    GetNelements() const {return fNelements;}
   Int_t                    GetNelementsRN() const {return fNelementsRN;}
   void                     ExportElementsRN(const char *filename="");

   ClassDef(TGeoElementTable,3)              // table of elements
};

#endif

 TGeoElement.h:1
 TGeoElement.h:2
 TGeoElement.h:3
 TGeoElement.h:4
 TGeoElement.h:5
 TGeoElement.h:6
 TGeoElement.h:7
 TGeoElement.h:8
 TGeoElement.h:9
 TGeoElement.h:10
 TGeoElement.h:11
 TGeoElement.h:12
 TGeoElement.h:13
 TGeoElement.h:14
 TGeoElement.h:15
 TGeoElement.h:16
 TGeoElement.h:17
 TGeoElement.h:18
 TGeoElement.h:19
 TGeoElement.h:20
 TGeoElement.h:21
 TGeoElement.h:22
 TGeoElement.h:23
 TGeoElement.h:24
 TGeoElement.h:25
 TGeoElement.h:26
 TGeoElement.h:27
 TGeoElement.h:28
 TGeoElement.h:29
 TGeoElement.h:30
 TGeoElement.h:31
 TGeoElement.h:32
 TGeoElement.h:33
 TGeoElement.h:34
 TGeoElement.h:35
 TGeoElement.h:36
 TGeoElement.h:37
 TGeoElement.h:38
 TGeoElement.h:39
 TGeoElement.h:40
 TGeoElement.h:41
 TGeoElement.h:42
 TGeoElement.h:43
 TGeoElement.h:44
 TGeoElement.h:45
 TGeoElement.h:46
 TGeoElement.h:47
 TGeoElement.h:48
 TGeoElement.h:49
 TGeoElement.h:50
 TGeoElement.h:51
 TGeoElement.h:52
 TGeoElement.h:53
 TGeoElement.h:54
 TGeoElement.h:55
 TGeoElement.h:56
 TGeoElement.h:57
 TGeoElement.h:58
 TGeoElement.h:59
 TGeoElement.h:60
 TGeoElement.h:61
 TGeoElement.h:62
 TGeoElement.h:63
 TGeoElement.h:64
 TGeoElement.h:65
 TGeoElement.h:66
 TGeoElement.h:67
 TGeoElement.h:68
 TGeoElement.h:69
 TGeoElement.h:70
 TGeoElement.h:71
 TGeoElement.h:72
 TGeoElement.h:73
 TGeoElement.h:74
 TGeoElement.h:75
 TGeoElement.h:76
 TGeoElement.h:77
 TGeoElement.h:78
 TGeoElement.h:79
 TGeoElement.h:80
 TGeoElement.h:81
 TGeoElement.h:82
 TGeoElement.h:83
 TGeoElement.h:84
 TGeoElement.h:85
 TGeoElement.h:86
 TGeoElement.h:87
 TGeoElement.h:88
 TGeoElement.h:89
 TGeoElement.h:90
 TGeoElement.h:91
 TGeoElement.h:92
 TGeoElement.h:93
 TGeoElement.h:94
 TGeoElement.h:95
 TGeoElement.h:96
 TGeoElement.h:97
 TGeoElement.h:98
 TGeoElement.h:99
 TGeoElement.h:100
 TGeoElement.h:101
 TGeoElement.h:102
 TGeoElement.h:103
 TGeoElement.h:104
 TGeoElement.h:105
 TGeoElement.h:106
 TGeoElement.h:107
 TGeoElement.h:108
 TGeoElement.h:109
 TGeoElement.h:110
 TGeoElement.h:111
 TGeoElement.h:112
 TGeoElement.h:113
 TGeoElement.h:114
 TGeoElement.h:115
 TGeoElement.h:116
 TGeoElement.h:117
 TGeoElement.h:118
 TGeoElement.h:119
 TGeoElement.h:120
 TGeoElement.h:121
 TGeoElement.h:122
 TGeoElement.h:123
 TGeoElement.h:124
 TGeoElement.h:125
 TGeoElement.h:126
 TGeoElement.h:127
 TGeoElement.h:128
 TGeoElement.h:129
 TGeoElement.h:130
 TGeoElement.h:131
 TGeoElement.h:132
 TGeoElement.h:133
 TGeoElement.h:134
 TGeoElement.h:135
 TGeoElement.h:136
 TGeoElement.h:137
 TGeoElement.h:138
 TGeoElement.h:139
 TGeoElement.h:140
 TGeoElement.h:141
 TGeoElement.h:142
 TGeoElement.h:143
 TGeoElement.h:144
 TGeoElement.h:145
 TGeoElement.h:146
 TGeoElement.h:147
 TGeoElement.h:148
 TGeoElement.h:149
 TGeoElement.h:150
 TGeoElement.h:151
 TGeoElement.h:152
 TGeoElement.h:153
 TGeoElement.h:154
 TGeoElement.h:155
 TGeoElement.h:156
 TGeoElement.h:157
 TGeoElement.h:158
 TGeoElement.h:159
 TGeoElement.h:160
 TGeoElement.h:161
 TGeoElement.h:162
 TGeoElement.h:163
 TGeoElement.h:164
 TGeoElement.h:165
 TGeoElement.h:166
 TGeoElement.h:167
 TGeoElement.h:168
 TGeoElement.h:169
 TGeoElement.h:170
 TGeoElement.h:171
 TGeoElement.h:172
 TGeoElement.h:173
 TGeoElement.h:174
 TGeoElement.h:175
 TGeoElement.h:176
 TGeoElement.h:177
 TGeoElement.h:178
 TGeoElement.h:179
 TGeoElement.h:180
 TGeoElement.h:181
 TGeoElement.h:182
 TGeoElement.h:183
 TGeoElement.h:184
 TGeoElement.h:185
 TGeoElement.h:186
 TGeoElement.h:187
 TGeoElement.h:188
 TGeoElement.h:189
 TGeoElement.h:190
 TGeoElement.h:191
 TGeoElement.h:192
 TGeoElement.h:193
 TGeoElement.h:194
 TGeoElement.h:195
 TGeoElement.h:196
 TGeoElement.h:197
 TGeoElement.h:198
 TGeoElement.h:199
 TGeoElement.h:200
 TGeoElement.h:201
 TGeoElement.h:202
 TGeoElement.h:203
 TGeoElement.h:204
 TGeoElement.h:205
 TGeoElement.h:206
 TGeoElement.h:207
 TGeoElement.h:208
 TGeoElement.h:209
 TGeoElement.h:210
 TGeoElement.h:211
 TGeoElement.h:212
 TGeoElement.h:213
 TGeoElement.h:214
 TGeoElement.h:215
 TGeoElement.h:216
 TGeoElement.h:217
 TGeoElement.h:218
 TGeoElement.h:219
 TGeoElement.h:220
 TGeoElement.h:221
 TGeoElement.h:222
 TGeoElement.h:223
 TGeoElement.h:224
 TGeoElement.h:225
 TGeoElement.h:226
 TGeoElement.h:227
 TGeoElement.h:228
 TGeoElement.h:229
 TGeoElement.h:230
 TGeoElement.h:231
 TGeoElement.h:232
 TGeoElement.h:233
 TGeoElement.h:234
 TGeoElement.h:235
 TGeoElement.h:236
 TGeoElement.h:237
 TGeoElement.h:238
 TGeoElement.h:239
 TGeoElement.h:240
 TGeoElement.h:241
 TGeoElement.h:242
 TGeoElement.h:243
 TGeoElement.h:244
 TGeoElement.h:245
 TGeoElement.h:246
 TGeoElement.h:247
 TGeoElement.h:248
 TGeoElement.h:249
 TGeoElement.h:250
 TGeoElement.h:251
 TGeoElement.h:252
 TGeoElement.h:253
 TGeoElement.h:254
 TGeoElement.h:255
 TGeoElement.h:256
 TGeoElement.h:257
 TGeoElement.h:258
 TGeoElement.h:259
 TGeoElement.h:260
 TGeoElement.h:261
 TGeoElement.h:262
 TGeoElement.h:263
 TGeoElement.h:264
 TGeoElement.h:265
 TGeoElement.h:266
 TGeoElement.h:267
 TGeoElement.h:268
 TGeoElement.h:269
 TGeoElement.h:270
 TGeoElement.h:271
 TGeoElement.h:272
 TGeoElement.h:273
 TGeoElement.h:274
 TGeoElement.h:275
 TGeoElement.h:276
 TGeoElement.h:277
 TGeoElement.h:278
 TGeoElement.h:279
 TGeoElement.h:280
 TGeoElement.h:281
 TGeoElement.h:282
 TGeoElement.h:283
 TGeoElement.h:284
 TGeoElement.h:285
 TGeoElement.h:286
 TGeoElement.h:287
 TGeoElement.h:288
 TGeoElement.h:289
 TGeoElement.h:290
 TGeoElement.h:291
 TGeoElement.h:292
 TGeoElement.h:293
 TGeoElement.h:294
 TGeoElement.h:295
 TGeoElement.h:296
 TGeoElement.h:297
 TGeoElement.h:298
 TGeoElement.h:299
 TGeoElement.h:300
 TGeoElement.h:301
 TGeoElement.h:302
 TGeoElement.h:303
 TGeoElement.h:304
 TGeoElement.h:305
 TGeoElement.h:306
 TGeoElement.h:307
 TGeoElement.h:308
 TGeoElement.h:309
 TGeoElement.h:310
 TGeoElement.h:311
 TGeoElement.h:312
 TGeoElement.h:313
 TGeoElement.h:314
 TGeoElement.h:315
 TGeoElement.h:316
 TGeoElement.h:317
 TGeoElement.h:318
 TGeoElement.h:319
 TGeoElement.h:320
 TGeoElement.h:321
 TGeoElement.h:322
 TGeoElement.h:323
 TGeoElement.h:324
 TGeoElement.h:325
 TGeoElement.h:326
 TGeoElement.h:327
 TGeoElement.h:328
 TGeoElement.h:329
 TGeoElement.h:330
 TGeoElement.h:331
 TGeoElement.h:332
 TGeoElement.h:333
 TGeoElement.h:334
 TGeoElement.h:335
 TGeoElement.h:336
 TGeoElement.h:337
 TGeoElement.h:338
 TGeoElement.h:339
 TGeoElement.h:340
 TGeoElement.h:341
 TGeoElement.h:342
 TGeoElement.h:343
 TGeoElement.h:344
 TGeoElement.h:345
 TGeoElement.h:346
 TGeoElement.h:347
 TGeoElement.h:348
 TGeoElement.h:349
 TGeoElement.h:350
 TGeoElement.h:351
 TGeoElement.h:352
 TGeoElement.h:353
 TGeoElement.h:354
 TGeoElement.h:355
 TGeoElement.h:356
 TGeoElement.h:357
 TGeoElement.h:358
 TGeoElement.h:359
 TGeoElement.h:360
 TGeoElement.h:361
 TGeoElement.h:362
 TGeoElement.h:363
 TGeoElement.h:364
 TGeoElement.h:365