Logo ROOT  
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
28class TGeoIsotope;
29
30////////////////////////////////////////////////////////////////////////////
31// //
32// TGeoElement - a chemical element //
33// //
34////////////////////////////////////////////////////////////////////////////
35
36class TGeoElement : public TNamed
37{
38protected:
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
54private:
55 TGeoElement(const TGeoElement &other) = delete;
56 TGeoElement &operator=(const TGeoElement &other) = delete;
57
58 // Compute the Coulomb correction factor
60 // Compute the Tsai formula for the radiation length
62
63public:
64 // constructors
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;}
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
108class TGeoIsotope : public TNamed
109{
110protected:
111 Int_t fZ; // atomic number
112 Int_t fN; // number of nucleons
113 Double_t fA; // atomic mass (g/mole)
114
115public:
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
135class TGeoDecayChannel;
136class TGeoBatemanSol;
137
139{
140protected:
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
159private:
160 TGeoElementRN(const TGeoElementRN& elem) = delete;
161 TGeoElementRN& operator=(const TGeoElementRN& elem) = delete;
162
163public:
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
217{
218private:
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
225public:
227 kBitMask32 = 0xffffffff,
233 kECF = BIT(5),
236 kI = BIT(8),
238 k2P = BIT(10),
239 k2N = BIT(11),
240 k2A = BIT(12),
242 kCarbon14 = BIT(14)
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;}
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
281class TGeoBatemanSol : public TObject, public TAttLine, public TAttFill, public TAttMarker
282{
283private:
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
296public:
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);
302
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{
330private:
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
338protected:
339 TGeoElemIter() : fTop(0), fElem(0), fBranch(0), fLevel(0), fLimitRatio(0), fRatio(0) {}
340 TGeoElementRN *Down(Int_t ibranch);
341 TGeoElementRN *Up();
342
343public:
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);
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
370{
371private:
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
384protected:
387
388public:
389 // constructors
391 TGeoElementTable(Int_t nelements);
392 // destructor
393 virtual ~TGeoElementTable();
394 // methods
395
398 kETRNElements = BIT(15)
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);
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
int Int_t
Definition: RtypesCore.h:45
unsigned int UInt_t
Definition: RtypesCore.h:46
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassDef(name, id)
Definition: Rtypes.h:325
#define BIT(n)
Definition: Rtypes.h:85
char name[80]
Definition: TGX11.cxx:110
Fill Area Attributes class.
Definition: TAttFill.h:19
Line Attributes class.
Definition: TAttLine.h:18
Marker Attributes class.
Definition: TAttMarker.h:19
Double_t Concentration(Double_t time) const
Find concentration of the element at a given time.
~TGeoBatemanSol()
Destructor.
Int_t GetNcoeff() const
Definition: TGeoElement.h:312
Double_t fFactor
Definition: TGeoElement.h:292
Double_t fTmax
Definition: TGeoElement.h:294
BtCoef_t * fCoeff
Definition: TGeoElement.h:295
void GetCoeff(Int_t i, Double_t &cn, Double_t &lambda) const
Definition: TGeoElement.h:308
virtual void Draw(Option_t *option="")
Draw the solution of Bateman equation versus time.
void SetRange(Double_t tmin=0., Double_t tmax=0.)
Definition: TGeoElement.h:314
void FindSolution(const TObjArray *array)
Find the solution for the Bateman equations corresponding to the decay chain described by an array en...
TGeoElementRN * fElem
Definition: TGeoElement.h:288
virtual void Print(Option_t *option="") const
Print concentration evolution.
TGeoElementRN * fElemTop
Definition: TGeoElement.h:289
void GetRange(Double_t &tmin, Double_t &tmax) const
Definition: TGeoElement.h:309
TGeoBatemanSol & operator=(const TGeoBatemanSol &other)
Assignment.
void SetFactor(Double_t factor)
Definition: TGeoElement.h:315
TGeoElementRN * GetTopElement() const
Definition: TGeoElement.h:311
void Normalize(Double_t factor)
Normalize all coefficients with a given factor.
TGeoElementRN * GetElement() const
Definition: TGeoElement.h:310
Double_t fTmin
Definition: TGeoElement.h:293
TGeoBatemanSol & operator+=(const TGeoBatemanSol &other)
Addition of other solution.
A decay channel for a radionuclide.
Definition: TGeoElement.h:217
void SetParent(TGeoElementRN *parent)
Definition: TGeoElement.h:264
virtual const char * GetName() const
Returns name of decay.
Int_t DeltaIso() const
Definition: TGeoElement.h:259
TGeoElementRN * fParent
Definition: TGeoElement.h:223
Double_t Qvalue() const
Definition: TGeoElement.h:258
TGeoElementRN * Daughter() const
Definition: TGeoElement.h:260
UInt_t Decay() const
Definition: TGeoElement.h:256
virtual void Print(Option_t *opt=" ") const
Prints decay info.
TGeoDecayChannel(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue)
Definition: TGeoElement.h:245
static TGeoDecayChannel * ReadDecay(const char *record)
Create element from line record.
TGeoElementRN * Parent() const
Definition: TGeoElement.h:261
virtual ~TGeoDecayChannel()
Definition: TGeoElement.h:249
Double_t fQvalue
Definition: TGeoElement.h:222
TGeoElementRN * fDaughter
Definition: TGeoElement.h:224
Double_t BranchingRatio() const
Definition: TGeoElement.h:257
Double_t fBranchingRatio
Definition: TGeoElement.h:221
void SetDaughter(TGeoElementRN *daughter)
Definition: TGeoElement.h:265
TGeoDecayChannel & operator=(const TGeoDecayChannel &dc)
Assignment.
static void DecayName(UInt_t decay, TString &name)
Returns decay name.
TGeoDecayChannel(const TGeoDecayChannel &dc)
Definition: TGeoElement.h:247
virtual void DecayShift(Int_t &dA, Int_t &dZ, Int_t &dI) const
Returns variation in A, Z and Iso after decay.
Int_t GetIndex() const
Get index of this channel in the list of decays of the parent nuclide.
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save primitive for decays.
Iterator for decay branches.
Definition: TGeoElement.h:329
virtual void Print(Option_t *option="") const
Print info about the current decay branch.
Double_t fRatio
Definition: TGeoElement.h:336
void SetLimitRatio(Double_t limit)
Definition: TGeoElement.h:358
TObjArray * GetBranch() const
Definition: TGeoElement.h:352
Double_t GetRatio() const
Definition: TGeoElement.h:356
const TGeoElementRN * fElem
Definition: TGeoElement.h:332
TObjArray * fBranch
Definition: TGeoElement.h:333
TGeoElementRN * Next()
Return next element.
TGeoElemIter & operator=(const TGeoElemIter &iter)
Assignment.
virtual ~TGeoElemIter()
Destructor.
TGeoElementRN * operator()()
() operator.
const TGeoElementRN * fTop
Definition: TGeoElement.h:331
Double_t fLimitRatio
Definition: TGeoElement.h:335
TGeoElementRN * Up()
Go upwards from the current location until the next branching, then down.
const TGeoElementRN * GetElement() const
Definition: TGeoElement.h:354
TGeoElementRN * Down(Int_t ibranch)
Go downwards from current level via ibranch as low in the tree as possible.
const TGeoElementRN * GetTop() const
Definition: TGeoElement.h:353
Int_t GetLevel() const
Definition: TGeoElement.h:355
Class representing a radionuclidevoid TGeoManager::SetDefaultRootUnits() { if ( fgDefaultUnits == kRo...
Definition: TGeoElement.h:139
Double_t fNatAbun
Definition: TGeoElement.h:146
void AddRatio(TGeoBatemanSol &ratio)
Adds a proportion ratio to the existing one.
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.
TGeoElementRN & operator=(const TGeoElementRN &elem)=delete
TGeoElementRN(const TGeoElementRN &elem)=delete
Double_t TG_S() const
Definition: TGeoElement.h:192
void AddDecay(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue)
Adds a decay mode for this element.
Double_t fHalfLife
Definition: TGeoElement.h:145
virtual Bool_t IsRadioNuclide() const
Definition: TGeoElement.h:180
TObjArray * fDecays
Definition: TGeoElement.h:155
Double_t TG_F() const
Definition: TGeoElement.h:190
Double_t Level() const
Definition: TGeoElement.h:184
Int_t AtomicNo() const
Definition: TGeoElement.h:182
Double_t fTH_S
Definition: TGeoElement.h:150
const char * PJ() const
Definition: TGeoElement.h:188
Int_t MassNo() const
Definition: TGeoElement.h:181
virtual Int_t ENDFCode() const
Definition: TGeoElement.h:178
Double_t fLevel
Definition: TGeoElement.h:143
Int_t IsoNo() const
Definition: TGeoElement.h:183
TGeoBatemanSol * fRatio
Definition: TGeoElement.h:153
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save primitive for RN elements.
Double_t HalfLife() const
Definition: TGeoElement.h:186
Double_t fDeltaM
Definition: TGeoElement.h:144
virtual Double_t GetSpecificActivity() const
Get the activity in Bq of a gram of material made from this element.
Int_t DecayResult(TGeoDecayChannel *dc) const
Returns ENDF code of decay result.
TGeoBatemanSol * Ratio() const
Definition: TGeoElement.h:197
Double_t MassEx() const
Definition: TGeoElement.h:185
TObjArray * Decays() const
Definition: TGeoElement.h:195
Bool_t Stable() const
Definition: TGeoElement.h:194
Int_t GetNdecays() const
Get number of decay channels of this element.
void MakeName(Int_t a, Int_t z, Int_t iso)
Generate a default name for the element.
TGeoElementRN()
Default constructor.
Bool_t CheckDecays() const
Check if all decay chain of the element is OK.
static TGeoElementRN * ReadElementRN(const char *record, Int_t &ndecays)
Create element from line record.
Double_t TH_S() const
Definition: TGeoElement.h:191
virtual ~TGeoElementRN()
Destructor.
Double_t TH_F() const
Definition: TGeoElement.h:189
Double_t fTG_F
Definition: TGeoElement.h:149
Double_t Status() const
Definition: TGeoElement.h:193
Double_t fTH_F
Definition: TGeoElement.h:148
static Int_t ENDF(Int_t a, Int_t z, Int_t iso)
Definition: TGeoElement.h:175
void ResetRatio()
Clears the existing ratio.
Double_t fTG_S
Definition: TGeoElement.h:151
Double_t NatAbun() const
Definition: TGeoElement.h:187
virtual void Print(Option_t *option="") const
Print info about the element;.
Table of elements.
Definition: TGeoElement.h:370
Int_t GetNelementsRN() const
Definition: TGeoElement.h:418
TGeoElementTable & operator=(const TGeoElementTable &)
assignment operator
Bool_t HasRNElements() const
Definition: TGeoElement.h:415
ElementRNMap_t::iterator ElementRNMapIt_t
Definition: TGeoElement.h:381
void ExportElementsRN(const char *filename="")
Export radionuclides in a file.
TObjArray * fListRN
Definition: TGeoElement.h:377
virtual ~TGeoElementTable()
destructor
void AddIsotope(TGeoIsotope *isotope)
Add isotope to the table.
ElementRNMap_t fElementsRN
Definition: TGeoElement.h:382
TGeoElementRN * GetElementRN(Int_t ENDFcode) const
Retrieve a radionuclide by ENDF code.
void AddElementRN(TGeoElementRN *elem)
Add a radionuclide to the table and map it.
Bool_t HasDefaultElements() const
Definition: TGeoElement.h:414
TObjArray * fList
Definition: TGeoElement.h:376
TObjArray * fIsotopes
Definition: TGeoElement.h:378
Bool_t CheckTable() const
Checks status of element table.
void ImportElementsRN()
Creates the list of radionuclides.
std::map< Int_t, TGeoElementRN * > ElementRNMap_t
Definition: TGeoElement.h:380
TGeoElement * GetElement(Int_t z)
Definition: TGeoElement.h:410
void AddElement(const char *name, const char *title, Int_t z, Double_t a)
Add an element to the table. Obsolete.
TObjArray * GetElementsRN() const
Definition: TGeoElement.h:413
virtual void Print(Option_t *option="") const
Print table of elements.
TGeoIsotope * FindIsotope(const char *name) const
Find existing isotope by name. Not optimized for a big number of isotopes.
void BuildDefaultElements()
Creates the default element table.
Int_t GetNelements() const
Definition: TGeoElement.h:417
TGeoElementTable()
default constructor
TGeoElement * FindElement(const char *name) const
Search an element by symbol or full name Exact matching.
Base class for chemical elements.
Definition: TGeoElement.h:37
Double_t fA
Definition: TGeoElement.h:48
Int_t N() const
Definition: TGeoElement.h:74
virtual Double_t GetSpecificActivity() const
Definition: TGeoElement.h:84
Int_t fNisotopes
Definition: TGeoElement.h:47
Double_t fRadTsai
Definition: TGeoElement.h:52
Bool_t IsDefined() const
Definition: TGeoElement.h:86
TGeoElement()
Default constructor.
Double_t A() const
Definition: TGeoElement.h:76
void SetDefined(Bool_t flag=kTRUE)
Definition: TGeoElement.h:90
virtual Bool_t IsRadioNuclide() const
Definition: TGeoElement.h:87
void ComputeDerivedQuantities()
Calculate properties for an atomic number.
Double_t Neff() const
Returns effective number of nucleons.
Int_t Z() const
Definition: TGeoElement.h:73
TGeoElement & operator=(const TGeoElement &other)=delete
void ComputeCoulombFactor()
Compute Coulomb correction factor (Phys Rev. D50 3-1 (1994) page 1254)
Double_t fCoulomb
Definition: TGeoElement.h:51
virtual Int_t ENDFCode() const
Definition: TGeoElement.h:72
void AddIsotope(TGeoIsotope *isotope, Double_t relativeAbundance)
Add an isotope for this element. All isotopes have to be isotopes of the same element.
TObjArray * fIsotopes
Definition: TGeoElement.h:49
TGeoElement(const TGeoElement &other)=delete
virtual void Print(Option_t *option="") const
Print this isotope.
static TGeoElementTable * GetElementTable()
Returns pointer to the table.
void ComputeLradTsaiFactor()
Compute Tsai's Expression for the Radiation Length (Phys Rev. D50 3-1 (1994) page 1254)
Double_t GetfCoulomb() const
Definition: TGeoElement.h:94
Int_t GetNisotopes() const
Definition: TGeoElement.h:78
Double_t * fAbundances
Definition: TGeoElement.h:50
Double_t GetfRadTsai() const
Definition: TGeoElement.h:96
virtual ~TGeoElement()
destructor
Bool_t HasIsotopes() const
Definition: TGeoElement.h:85
Double_t GetRelativeAbundance(Int_t i) const
Return relative abundance of i-th isotope in this element.
void SetUsed(Bool_t flag=kTRUE)
Definition: TGeoElement.h:91
TGeoIsotope * GetIsotope(Int_t i) const
Return i-th isotope in the element.
Bool_t IsUsed() const
Definition: TGeoElement.h:88
Double_t fA
Definition: TGeoElement.h:113
TGeoIsotope()
Dummy I/O constructor.
virtual ~TGeoIsotope()
Definition: TGeoElement.h:118
Int_t GetZ() const
Definition: TGeoElement.h:120
virtual void Print(Option_t *option="") const
Print this isotope.
Int_t GetN() const
Definition: TGeoElement.h:121
Double_t GetA() const
Definition: TGeoElement.h:122
static TGeoIsotope * FindIsotope(const char *name)
Find existing isotope by name.
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
TString fTitle
Definition: TNamed.h:33
An array of TObjects.
Definition: TObjArray.h:37
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
Mother of all ROOT objects.
Definition: TObject.h:37
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
Basic string class.
Definition: TString.h:136
const char * Data() const
Definition: TString.h:369
const Int_t n
Definition: legend1.C:16
auto * a
Definition: textangle.C:12