Logo ROOT   6.08/07
Reference Guide
TGeoElement.h
Go to the documentation of this file.
1 // @(#)root/geom:$Id$
2 // Author: Andrei Gheata 17/06/04
3 // Added support for radionuclides: Mihaela Gheata 24/08/2006
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 #ifndef ROOT_TGeoElement
13 #define ROOT_TGeoElement
14 
15 #ifndef ROOT_TNamed
16 #include "TNamed.h"
17 #endif
18 
19 #ifndef ROOT_TAttLine
20 #include "TAttLine.h"
21 #endif
22 
23 #ifndef ROOT_TAttFill
24 #include "TAttFill.h"
25 #endif
26 
27 #ifndef ROOT_TAttMarker
28 #include "TAttMarker.h"
29 #endif
30 
31 #ifndef ROOT_TObjArray
32 #include "TObjArray.h"
33 #endif
34 
35 #include <map>
36 
37 class TGeoElementTable;
38 class TGeoIsotope;
39 
40 ////////////////////////////////////////////////////////////////////////////
41 // //
42 // TGeoElement - a chemical element //
43 // //
44 ////////////////////////////////////////////////////////////////////////////
45 
46 class TGeoElement : public TNamed
47 {
48 protected:
49  enum EGeoElement {
50  kElemUsed = BIT(17),
53  };
54 
55  Int_t fZ; // Z of element
56  Int_t fN; // Number of nucleons
57  Int_t fNisotopes; // Number of isotopes for the element
58  Double_t fA; // A of element
59  TObjArray *fIsotopes; // List of isotopes
60  Double_t *fAbundances; //[fNisotopes] Array of relative isotope abundances
61 
62 private:
63  TGeoElement(const TGeoElement &other);
64  TGeoElement &operator=(const TGeoElement &other);
65 
66 public:
67  // constructors
68  TGeoElement();
69  TGeoElement(const char *name, const char *title, Int_t z, Double_t a);
70  TGeoElement(const char *name, const char *title, Int_t nisotopes);
71  TGeoElement(const char *name, const char *title, Int_t z, Int_t n, Double_t a);
72  // destructor
73  virtual ~TGeoElement() {;}
74  // methods
75  virtual Int_t ENDFCode() const { return 0;}
76  Int_t Z() const {return fZ;}
77  Int_t N() const {return fN;}
78  Double_t Neff() const;
79  Double_t A() const {return fA;}
80  void AddIsotope(TGeoIsotope *isotope, Double_t relativeAbundance);
81  Int_t GetNisotopes() const {return fNisotopes;}
82  TGeoIsotope *GetIsotope(Int_t i) const;
84  // Specific activity (in Bq/gram)
85  virtual Double_t GetSpecificActivity() const {return 0.;}
86  Bool_t HasIsotopes() const {return (fNisotopes==0)?kFALSE:kTRUE;}
88  virtual Bool_t IsRadioNuclide() const {return kFALSE;}
90  virtual void Print(Option_t *option = "") const;
94 
95 
96  ClassDef(TGeoElement, 2) // base element class
97 };
98 
99 ////////////////////////////////////////////////////////////////////////////
100 // //
101 // TGeoIsotope - a isotope defined by the atomic number, number of //
102 // nucleons and atomic weight (g/mole) //
103 // //
104 ////////////////////////////////////////////////////////////////////////////
105 
106 class TGeoIsotope : public TNamed
107 {
108 protected:
109  Int_t fZ; // atomic number
110  Int_t fN; // number of nucleons
111  Double_t fA; // atomic mass (g/mole)
112 
113 public:
114  TGeoIsotope();
115  TGeoIsotope(const char *name, Int_t z, Int_t n, Double_t a);
116  virtual ~TGeoIsotope() {}
117 
118  Int_t GetZ() const {return fZ;}
119  Int_t GetN() const {return fN;}
120  Double_t GetA() const {return fA;}
121  static TGeoIsotope *FindIsotope(const char *name);
122  virtual void Print(Option_t *option = "") const;
123 
124  ClassDef(TGeoIsotope, 1) // Isotope class defined by Z,N,A
125 };
126 
127 ////////////////////////////////////////////////////////////////////////////
128 // //
129 // TGeoElementRN - a radionuclide. //
130 // //
131 ////////////////////////////////////////////////////////////////////////////
132 
133 class TGeoDecayChannel;
134 class TGeoBatemanSol;
135 
137 {
138 protected:
139  Int_t fENDFcode; // ENDF element code
140  Int_t fIso; // Isomer number
141  Double_t fLevel; // Isomeric level
142  Double_t fDeltaM; // Mass excess
143  Double_t fHalfLife; // Half life
144  Double_t fNatAbun; // Natural Abundance
145 // char fJP[11]; // Spin-parity
146  Double_t fTH_F; // Hynalation toxicity
147  Double_t fTG_F; // Ingestion toxicity
148  Double_t fTH_S; // Hynalation toxicity
149  Double_t fTG_S; // Ingestion toxicity
150  Int_t fStatus; // Status code
151  TGeoBatemanSol *fRatio; // Time evolution of proportion by number
152 
153  TObjArray *fDecays; // List of decay modes
154 
155  void MakeName(Int_t a, Int_t z, Int_t iso);
156 
157 private:
158  TGeoElementRN(const TGeoElementRN& elem);
159  TGeoElementRN& operator=(const TGeoElementRN& elem);
160 
161 public:
162  TGeoElementRN();
163  TGeoElementRN(Int_t A, Int_t Z, Int_t iso, Double_t level,
164  Double_t deltaM, Double_t halfLife, const char* JP,
165  Double_t natAbun, Double_t th_f, Double_t tg_f, Double_t th_s,
166  Double_t tg_s, Int_t status);
167  virtual ~TGeoElementRN();
168 
169  void AddDecay(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue);
170  void AddDecay(TGeoDecayChannel *dc);
171  void AddRatio(TGeoBatemanSol &ratio);
172  void ResetRatio();
173  static Int_t ENDF(Int_t a, Int_t z, Int_t iso) {return 10000*z+10*a+iso;}
174 
175  // Getters
176  virtual Int_t ENDFCode() const {return fENDFcode;}
177  virtual Double_t GetSpecificActivity() const;
178  virtual Bool_t IsRadioNuclide() const {return kTRUE;}
179  Int_t MassNo() const {return (Int_t)fA;}
180  Int_t AtomicNo() const {return fZ;}
181  Int_t IsoNo() const {return fIso;}
182  Double_t Level() const {return fLevel;}
183  Double_t MassEx() const {return fDeltaM;}
184  Double_t HalfLife() const {return fHalfLife;}
185  Double_t NatAbun() const {return fNatAbun;}
186  const char* PJ() const {return fTitle.Data();}
187  Double_t TH_F() const {return fTH_F;}
188  Double_t TG_F() const {return fTG_F;}
189  Double_t TH_S() const {return fTH_S;}
190  Double_t TG_S() const {return fTG_S;}
191  Double_t Status() const {return fStatus;}
192  Bool_t Stable() const {return !fDecays;}
193  TObjArray *Decays() const {return fDecays;}
194  Int_t GetNdecays() const;
195  TGeoBatemanSol *Ratio() const {return fRatio;}
196 
197  // Utilities
198  Bool_t CheckDecays() const;
199  Int_t DecayResult(TGeoDecayChannel *dc) const;
200  void FillPopulation(TObjArray *population, Double_t precision=0.001, Double_t factor=1.);
201  virtual void Print(Option_t *option = "") const;
202  static TGeoElementRN *ReadElementRN(const char *record, Int_t &ndecays);
203  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
204 
205  ClassDef(TGeoElementRN, 2) // radionuclides class
206 };
207 
208 ////////////////////////////////////////////////////////////////////////////
209 // //
210 // TGeoDecayChannel - decay channel utility class. //
211 // //
212 ////////////////////////////////////////////////////////////////////////////
213 
214 class TGeoDecayChannel : public TObject
215 {
216 private:
217  UInt_t fDecay; // Decay mode
218  Int_t fDiso; // Delta isomeric number
219  Double_t fBranchingRatio; // Branching Ratio
220  Double_t fQvalue; // Qvalue in GeV
221  TGeoElementRN *fParent; // Parent element
222  TGeoElementRN *fDaughter; // Daughter element
223 public:
225  kBitMask32 = 0xffffffff,
226  k2BetaMinus = BIT(0),
227  kBetaMinus = BIT(1),
228  kNeutronEm = BIT(2),
229  kProtonEm = BIT(3),
230  kAlpha = BIT(4),
231  kECF = BIT(5),
232  kElecCapt = BIT(6),
233  kIsoTrans = BIT(7),
234  kI = BIT(8),
235  kSpontFiss = BIT(9),
236  k2P = BIT(10),
237  k2N = BIT(11),
238  k2A = BIT(12),
239  kCarbon12 = BIT(13),
240  kCarbon14 = BIT(14)
241  };
242  TGeoDecayChannel() : fDecay(0), fDiso(0), fBranchingRatio(0), fQvalue(0), fParent(0), fDaughter(0) {}
243  TGeoDecayChannel(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue)
244  : fDecay(decay), fDiso(diso), fBranchingRatio(branchingRatio), fQvalue(qValue), fParent(0), fDaughter(0) {}
245  TGeoDecayChannel(const TGeoDecayChannel &dc) : TObject(dc),fDecay(dc.fDecay),fDiso(dc.fDiso),fBranchingRatio(dc.fBranchingRatio),
246  fQvalue(dc.fQvalue),fParent(dc.fParent),fDaughter(dc.fDaughter) {}
247  virtual ~TGeoDecayChannel() {}
248 
250 
251  // Getters
252  Int_t GetIndex() const;
253  virtual const char *GetName() const;
254  UInt_t Decay() const {return fDecay;}
255  Double_t BranchingRatio() const {return fBranchingRatio;}
256  Double_t Qvalue() const {return fQvalue;}
257  Int_t DeltaIso() const {return fDiso;}
258  TGeoElementRN *Daughter() const {return fDaughter;}
259  TGeoElementRN *Parent() const {return fParent;}
260  static void DecayName(UInt_t decay, TString &name);
261  // Setters
262  void SetParent(TGeoElementRN *parent) {fParent = parent;}
263  void SetDaughter(TGeoElementRN *daughter) {fDaughter = daughter;}
264  // Services
265  virtual void Print(Option_t *opt = " ") const;
266  static TGeoDecayChannel *ReadDecay(const char *record);
267  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
268  virtual void DecayShift(Int_t &dA, Int_t &dZ, Int_t &dI) const ;
269 
270  ClassDef(TGeoDecayChannel,1) // Decay channel for Elements
271 };
272 
273 ////////////////////////////////////////////////////////////////////////////////
274 // //
275 // TGeoBatemanSol -Class representing the Bateman solution for a decay branch //
276 // //
277 ////////////////////////////////////////////////////////////////////////////////
278 
279 class TGeoBatemanSol : public TObject, public TAttLine, public TAttFill, public TAttMarker
280 {
281 private:
282  typedef struct {
283  Double_t cn; // Concentration for element 'i': Ni/Ntop
284  Double_t lambda; // Decay coef. for element 'i'
285  } BtCoef_t;
286  TGeoElementRN *fElem; // Referred RN element
287  TGeoElementRN *fElemTop; // Top RN element
288  Int_t fCsize; // Size of the array of coefficients
289  Int_t fNcoeff; // Number of coefficients
290  Double_t fFactor; // Constant factor that applies to all coefficients
291  Double_t fTmin; // Minimum value of the time interval
292  Double_t fTmax; // Maximum value of the time interval
293  BtCoef_t *fCoeff; //[fNcoeff] Array of coefficients
294 public:
295  TGeoBatemanSol() : TObject(), TAttLine(), TAttFill(), TAttMarker(), fElem(NULL), fElemTop(NULL), fCsize(0), fNcoeff(0), fFactor(1.), fTmin(0.), fTmax(0), fCoeff(NULL) {}
297  TGeoBatemanSol(const TObjArray *chain);
298  TGeoBatemanSol(const TGeoBatemanSol& other);
299  ~TGeoBatemanSol();
300 
301  TGeoBatemanSol& operator=(const TGeoBatemanSol& other);
302  TGeoBatemanSol& operator+=(const TGeoBatemanSol& other);
303 
304  Double_t Concentration(Double_t time) const;
305  virtual void Draw(Option_t *option="");
306  void GetCoeff(Int_t i, Double_t &cn, Double_t &lambda) const {cn=fCoeff[i].cn; lambda=fCoeff[i].lambda;}
307  void GetRange(Double_t &tmin, Double_t &tmax) const {tmin=fTmin; tmax=fTmax;}
308  TGeoElementRN *GetElement() const {return fElem;}
309  TGeoElementRN *GetTopElement() const {return fElemTop;}
310  Int_t GetNcoeff() const {return fNcoeff;}
311  virtual void Print(Option_t *option = "") const;
312  void SetRange(Double_t tmin=0., Double_t tmax=0.) {fTmin=tmin; fTmax=tmax;}
313  void SetFactor(Double_t factor) {fFactor = factor;}
314  void FindSolution(const TObjArray *array);
315  void Normalize(Double_t factor);
316 
317  ClassDef(TGeoBatemanSol,1) // Solution for the Bateman equation
318 };
319 
320 ////////////////////////////////////////////////////////////////////////////
321 // //
322 // TGeoElemIter - iterator for decay chains. //
323 // //
324 ////////////////////////////////////////////////////////////////////////////
325 
327 {
328 private:
329  const TGeoElementRN *fTop; // Top element of the iteration
330  const TGeoElementRN *fElem; // Current element
331  TObjArray *fBranch; // Current branch
332  Int_t fLevel; // Current level
333  Double_t fLimitRatio; // Minimum cumulative branching ratio
334  Double_t fRatio; // Current ratio
335 
336 protected:
337  TGeoElemIter() : fTop(0), fElem(0), fBranch(0), fLevel(0), fLimitRatio(0), fRatio(0) {}
338  TGeoElementRN *Down(Int_t ibranch);
339  TGeoElementRN *Up();
340 
341 public:
342  TGeoElemIter(TGeoElementRN *top, Double_t limit=1.e-4);
343  TGeoElemIter(const TGeoElemIter &iter);
344  virtual ~TGeoElemIter();
345 
346  TGeoElemIter &operator=(const TGeoElemIter &iter);
347  TGeoElementRN *operator()();
348  TGeoElementRN *Next();
349 
350  TObjArray *GetBranch() const {return fBranch;}
351  const TGeoElementRN *GetTop() const {return fTop;}
352  const TGeoElementRN *GetElement() const {return fElem;}
353  Int_t GetLevel() const {return fLevel;}
354  Double_t GetRatio() const {return fRatio;}
355  virtual void Print(Option_t *option="") const;
356  void SetLimitRatio(Double_t limit) {fLimitRatio = limit;}
357 
358  ClassDef(TGeoElemIter,0) // Iterator for radionuclide chains.
359 };
360 
361 ////////////////////////////////////////////////////////////////////////////
362 // //
363 // TGeoElementTable - table of elements //
364 // //
365 ////////////////////////////////////////////////////////////////////////////
366 
367 class TGeoElementTable : public TObject
368 {
369 private:
370 // data members
371  Int_t fNelements; // number of elements
372  Int_t fNelementsRN; // number of RN elements
373  Int_t fNisotopes; // number of isotopes
374  TObjArray *fList; // list of elements
375  TObjArray *fListRN; // list of RN elements
376  TObjArray *fIsotopes; // list of user-defined isotopes
377  // Map of radionuclides
378  typedef std::map<Int_t, TGeoElementRN *> ElementRNMap_t;
379  typedef ElementRNMap_t::iterator ElementRNMapIt_t;
380  ElementRNMap_t fElementsRN; //! map of RN elements with ENDF key
381 
382 protected:
385 
386 public:
387  // constructors
389  TGeoElementTable(Int_t nelements);
390  // destructor
391  virtual ~TGeoElementTable();
392  // methods
393 
395  kETDefaultElements = BIT(14),
396  kETRNElements = BIT(15)
397  };
398  void AddElement(const char *name, const char *title, Int_t z, Double_t a);
399  void AddElement(const char *name, const char *title, Int_t z, Int_t n, Double_t a);
400  void AddElement(TGeoElement *elem);
401  void AddElementRN(TGeoElementRN *elem);
402  void AddIsotope(TGeoIsotope *isotope);
403  void BuildDefaultElements();
404  void ImportElementsRN();
405  Bool_t CheckTable() const;
406  TGeoElement *FindElement(const char *name) const;
407  TGeoIsotope *FindIsotope(const char *name) const;
408  TGeoElement *GetElement(Int_t z) {return (TGeoElement*)fList->At(z);}
409  TGeoElementRN *GetElementRN(Int_t ENDFcode) const;
410  TGeoElementRN *GetElementRN(Int_t a, Int_t z, Int_t iso=0) const;
411  TObjArray *GetElementsRN() const {return fListRN;}
412  Bool_t HasDefaultElements() const {return TObject::TestBit(kETDefaultElements);}
413  Bool_t HasRNElements() const {return TObject::TestBit(kETRNElements);}
414 
415  Int_t GetNelements() const {return fNelements;}
416  Int_t GetNelementsRN() const {return fNelementsRN;}
417  void ExportElementsRN(const char *filename="");
418  virtual void Print(Option_t *option = "") const;
419 
420  ClassDef(TGeoElementTable,4) // table of elements
421 };
422 
423 #endif
424 
Int_t GetZ() const
Definition: TGeoElement.h:118
TString fTitle
Definition: TNamed.h:37
Int_t AtomicNo() const
Definition: TGeoElement.h:180
TObjArray * GetBranch() const
Definition: TGeoElement.h:350
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:51
virtual Bool_t IsRadioNuclide() const
Definition: TGeoElement.h:178
An array of TObjects.
Definition: TObjArray.h:39
virtual ~TGeoElement()
Definition: TGeoElement.h:73
Float_t Normalize(Float_t v[3])
Normalize a vector v in place.
Definition: TMath.cxx:498
Int_t DeltaIso() const
Definition: TGeoElement.h:257
Table of elements.
Definition: TGeoElement.h:367
Double_t fHalfLife
Definition: TGeoElement.h:143
Double_t fTmin
Definition: TGeoElement.h:291
Double_t TH_S() const
Definition: TGeoElement.h:189
Double_t TG_F() const
Definition: TGeoElement.h:188
TGeoElementRN * Daughter() const
Definition: TGeoElement.h:258
const char Option_t
Definition: RtypesCore.h:62
TObjArray * fListRN
Definition: TGeoElement.h:375
TGeoElement()
Default constructor.
Definition: TGeoElement.cxx:86
Int_t Z() const
Definition: TGeoElement.h:76
Bool_t TestBit(UInt_t f) const
Definition: TObject.h:157
#define BIT(n)
Definition: Rtypes.h:120
TGeoElementRN * fParent
Definition: TGeoElement.h:221
TGeoElementRN * GetElement() const
Definition: TGeoElement.h:308
Double_t fFactor
Definition: TGeoElement.h:290
UInt_t Decay() const
Definition: TGeoElement.h:254
Basic string class.
Definition: TString.h:137
Double_t GetA() const
Definition: TGeoElement.h:120
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
TArc * a
Definition: textangle.C:12
const Bool_t kFALSE
Definition: Rtypes.h:92
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition: TObject.cxx:255
void SetLimitRatio(Double_t limit)
Definition: TGeoElement.h:356
TObject * At(Int_t idx) const
Definition: TObjArray.h:167
TGeoIsotope * GetIsotope(Int_t i) const
Return i-th isotope in the element.
Double_t fTH_F
Definition: TGeoElement.h:146
void GetCoeff(Int_t i, Double_t &cn, Double_t &lambda) const
Definition: TGeoElement.h:306
TObjArray * fIsotopes
Definition: TGeoElement.h:376
TObjArray * fDecays
Definition: TGeoElement.h:153
Double_t Status() const
Definition: TGeoElement.h:191
Double_t * fAbundances
Definition: TGeoElement.h:60
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:739
TGeoElementRN * fElemTop
Definition: TGeoElement.h:287
const TGeoElementRN * fTop
Definition: TGeoElement.h:329
TObjArray * fList
Definition: TGeoElement.h:374
virtual Int_t ENDFCode() const
Definition: TGeoElement.h:176
Marker Attributes class.
Definition: TAttMarker.h:24
TGeoElementRN * Parent() const
Definition: TGeoElement.h:259
virtual Bool_t IsRadioNuclide() const
Definition: TGeoElement.h:88
void GetRange(Double_t &tmin, Double_t &tmax) const
Definition: TGeoElement.h:307
Bool_t HasIsotopes() const
Definition: TGeoElement.h:86
Double_t NatAbun() const
Definition: TGeoElement.h:185
Fill Area Attributes class.
Definition: TAttFill.h:24
TObjArray * Decays() const
Definition: TGeoElement.h:193
#define ClassDef(name, id)
Definition: Rtypes.h:254
Int_t GetNisotopes() const
Definition: TGeoElement.h:81
Double_t fA
Definition: TGeoElement.h:58
Int_t GetN() const
Definition: TGeoElement.h:119
Double_t Neff() const
Returns effective number of nucleons.
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:33
TObjArray * fBranch
Definition: TGeoElement.h:331
Bool_t IsUsed() const
Definition: TGeoElement.h:89
void AddIsotope(TGeoIsotope *isotope, Double_t relativeAbundance)
Add an isotope for this element. All isotopes have to be isotopes of the same element.
Base class for chemical elements.
Definition: TGeoElement.h:46
Bool_t IsDefined() const
Definition: TGeoElement.h:87
static TGeoElementTable * GetElementTable()
Returns pointer to the table.
const TGeoElementRN * GetTop() const
Definition: TGeoElement.h:351
const char * PJ() const
Definition: TGeoElement.h:186
Double_t fTmax
Definition: TGeoElement.h:292
Int_t GetNelementsRN() const
Definition: TGeoElement.h:416
BtCoef_t * fCoeff
Definition: TGeoElement.h:293
void SetFactor(Double_t factor)
Definition: TGeoElement.h:313
Double_t HalfLife() const
Definition: TGeoElement.h:184
Bool_t HasRNElements() const
Definition: TGeoElement.h:413
Double_t Qvalue() const
Definition: TGeoElement.h:256
Double_t Level() const
Definition: TGeoElement.h:182
Double_t TH_F() const
Definition: TGeoElement.h:187
void SetDaughter(TGeoElementRN *daughter)
Definition: TGeoElement.h:263
Double_t fLimitRatio
Definition: TGeoElement.h:333
Int_t IsoNo() const
Definition: TGeoElement.h:181
TObjArray * fIsotopes
Definition: TGeoElement.h:59
TGeoBatemanSol * Ratio() const
Definition: TGeoElement.h:195
std::map< Int_t, TGeoElementRN * > ElementRNMap_t
Definition: TGeoElement.h:378
TGeoElement & operator=(const TGeoElement &other)
TObjArray * GetElementsRN() const
Definition: TGeoElement.h:411
virtual ~TGeoDecayChannel()
Definition: TGeoElement.h:247
const TGeoElementRN * fElem
Definition: TGeoElement.h:330
Double_t fLevel
Definition: TGeoElement.h:141
Double_t fTG_F
Definition: TGeoElement.h:147
Double_t fBranchingRatio
Definition: TGeoElement.h:219
unsigned int UInt_t
Definition: RtypesCore.h:42
Iterator for decay branches.
Definition: TGeoElement.h:326
Int_t GetNelements() const
Definition: TGeoElement.h:415
Double_t fDeltaM
Definition: TGeoElement.h:142
TGeoDecayChannel(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue)
Definition: TGeoElement.h:243
TGeoDecayChannel(const TGeoDecayChannel &dc)
Definition: TGeoElement.h:245
Double_t fNatAbun
Definition: TGeoElement.h:144
const TGeoElementRN * GetElement() const
Definition: TGeoElement.h:352
virtual ~TGeoIsotope()
Definition: TGeoElement.h:116
void SetUsed(Bool_t flag=kTRUE)
Definition: TGeoElement.h:92
Bool_t HasDefaultElements() const
Definition: TGeoElement.h:412
ElementRNMap_t fElementsRN
Definition: TGeoElement.h:380
Double_t fQvalue
Definition: TGeoElement.h:220
double Double_t
Definition: RtypesCore.h:55
Double_t fTH_S
Definition: TGeoElement.h:148
Int_t GetNcoeff() const
Definition: TGeoElement.h:310
virtual void Print(Option_t *option="") const
Print this isotope.
TGeoElementRN * fElem
Definition: TGeoElement.h:286
void SetParent(TGeoElementRN *parent)
Definition: TGeoElement.h:262
ElementRNMap_t::iterator ElementRNMapIt_t
Definition: TGeoElement.h:379
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
Definition: TRolke.cxx:630
void SetDefined(Bool_t flag=kTRUE)
Definition: TGeoElement.h:91
Int_t fNisotopes
Definition: TGeoElement.h:57
Double_t GetRatio() const
Definition: TGeoElement.h:354
A decay channel for a radionuclide.
Definition: TGeoElement.h:214
Mother of all ROOT objects.
Definition: TObject.h:37
you should not use this method at all Int_t Int_t z
Definition: TRolke.cxx:630
Double_t fRatio
Definition: TGeoElement.h:334
Double_t MassEx() const
Definition: TGeoElement.h:183
Class representing a radionuclide.
Definition: TGeoElement.h:136
virtual Double_t GetSpecificActivity() const
Definition: TGeoElement.h:85
Double_t TG_S() const
Definition: TGeoElement.h:190
TGeoElementRN * fDaughter
Definition: TGeoElement.h:222
#define NULL
Definition: Rtypes.h:82
TGeoElementRN * GetTopElement() const
Definition: TGeoElement.h:309
static Int_t ENDF(Int_t a, Int_t z, Int_t iso)
Definition: TGeoElement.h:173
TGeoBatemanSol * fRatio
Definition: TGeoElement.h:151
Int_t N() const
Definition: TGeoElement.h:77
Double_t fTG_S
Definition: TGeoElement.h:149
Double_t A() const
Definition: TGeoElement.h:79
TGeoElement * GetElement(Int_t z)
Definition: TGeoElement.h:408
Int_t MassNo() const
Definition: TGeoElement.h:179
Double_t GetRelativeAbundance(Int_t i) const
Return relative abundance of i-th isotope in this element.
const Bool_t kTRUE
Definition: Rtypes.h:91
Bool_t Stable() const
Definition: TGeoElement.h:192
Int_t GetLevel() const
Definition: TGeoElement.h:353
virtual Int_t ENDFCode() const
Definition: TGeoElement.h:75
void SetRange(Double_t tmin=0., Double_t tmax=0.)
Definition: TGeoElement.h:312
const Int_t n
Definition: legend1.C:16
Line Attributes class.
Definition: TAttLine.h:24
Double_t BranchingRatio() const
Definition: TGeoElement.h:255
char name[80]
Definition: TGX11.cxx:109
Double_t fA
Definition: TGeoElement.h:111
const char * Data() const
Definition: TString.h:349
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a primitive as a C++ statement(s) on output stream "out".
Definition: TObject.cxx:709