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