Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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 {
37protected:
39
40 Int_t fZ; // Z of element
41 Int_t fN; // Number of nucleons
42 Int_t fNisotopes; // Number of isotopes for the element
43 Double_t fA; // A of element
44 TObjArray *fIsotopes; // List of isotopes
45 Double_t *fAbundances; //[fNisotopes] Array of relative isotope abundances
46 Double_t fCoulomb; // Coulomb correction factor
47 Double_t fRadTsai; // Tsai formula for the radiation length
48
49private:
50 TGeoElement(const TGeoElement &other) = delete;
51 TGeoElement &operator=(const TGeoElement &other) = delete;
52
53 // Compute the Coulomb correction factor
55 // Compute the Tsai formula for the radiation length
57
58public:
59 // constructors
61 TGeoElement(const char *name, const char *title, Int_t z, Double_t a);
62 TGeoElement(const char *name, const char *title, Int_t nisotopes);
63 TGeoElement(const char *name, const char *title, Int_t z, Int_t n, Double_t a);
64 // destructor
65 ~TGeoElement() override;
66 // methods
67 virtual Int_t ENDFCode() const { return 0; }
68 Int_t Z() const { return fZ; }
69 Int_t N() const { return fN; }
70 Double_t Neff() const;
71 Double_t A() const { return fA; }
72 void AddIsotope(TGeoIsotope *isotope, Double_t relativeAbundance);
73 Int_t GetNisotopes() const { return fNisotopes; }
76 // Calculate properties for an atomic number
78 // Specific activity (in Bq/gram)
79 virtual Double_t GetSpecificActivity() const { return 0.; }
80 Bool_t HasIsotopes() const { return (fNisotopes == 0) ? kFALSE : kTRUE; }
82 virtual Bool_t IsRadioNuclide() const { return kFALSE; }
84 void Print(Option_t *option = "") const override;
86 void SetUsed(Bool_t flag = kTRUE) { TObject::SetBit(kElemUsed, flag); }
88 // Coulomb correction factor
89 inline Double_t GetfCoulomb() const { return fCoulomb; }
90 // Tsai formula for the radiation length
91 inline Double_t GetfRadTsai() const { return fRadTsai; }
92
93 ClassDefOverride(TGeoElement, 3) // base element class
94};
95
96////////////////////////////////////////////////////////////////////////////
97// //
98// TGeoIsotope - a isotope defined by the atomic number, number of //
99// nucleons and atomic weight (g/mole) //
100// //
101////////////////////////////////////////////////////////////////////////////
102
103class TGeoIsotope : public TNamed {
104protected:
105 Int_t fZ; // atomic number
106 Int_t fN; // number of nucleons
107 Double_t fA; // atomic mass (g/mole)
108
109public:
110 TGeoIsotope();
111 TGeoIsotope(const char *name, Int_t z, Int_t n, Double_t a);
112 ~TGeoIsotope() override {}
113
114 Int_t GetZ() const { return fZ; }
115 Int_t GetN() const { return fN; }
116 Double_t GetA() const { return fA; }
117 static TGeoIsotope *FindIsotope(const char *name);
118 void Print(Option_t *option = "") const override;
119
120 ClassDefOverride(TGeoIsotope, 1) // Isotope class defined by Z,N,A
121};
122
123////////////////////////////////////////////////////////////////////////////
124// //
125// TGeoElementRN - a radionuclide. //
126// //
127////////////////////////////////////////////////////////////////////////////
128
129class TGeoDecayChannel;
130class TGeoBatemanSol;
131
133protected:
134 Int_t fENDFcode; // ENDF element code
135 Int_t fIso; // Isomer number
136 Double_t fLevel; // Isomeric level
137 Double_t fDeltaM; // Mass excess
138 Double_t fHalfLife; // Half life
139 Double_t fNatAbun; // Natural Abundance
140 // char fJP[11]; // Spin-parity
141 Double_t fTH_F; // Hynalation toxicity
142 Double_t fTG_F; // Ingestion toxicity
143 Double_t fTH_S; // Hynalation toxicity
144 Double_t fTG_S; // Ingestion toxicity
145 Int_t fStatus; // Status code
146 TGeoBatemanSol *fRatio; // Time evolution of proportion by number
147
148 TObjArray *fDecays; // List of decay modes
149
150 void MakeName(Int_t a, Int_t z, Int_t iso);
151
152private:
153 TGeoElementRN(const TGeoElementRN &elem) = delete;
154 TGeoElementRN &operator=(const TGeoElementRN &elem) = delete;
155
156public:
158 TGeoElementRN(Int_t A, Int_t Z, Int_t iso, Double_t level, Double_t deltaM, Double_t halfLife, const char *JP,
159 Double_t natAbun, Double_t th_f, Double_t tg_f, Double_t th_s, Double_t tg_s, Int_t status);
160 ~TGeoElementRN() override;
161
162 void AddDecay(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue);
163 void AddDecay(TGeoDecayChannel *dc);
164 void AddRatio(TGeoBatemanSol &ratio);
165 void ResetRatio();
166 static Int_t ENDF(Int_t a, Int_t z, Int_t iso) { return 10000 * z + 10 * a + iso; }
167
168 // Getters
169 Int_t ENDFCode() const override { return fENDFcode; }
170 Double_t GetSpecificActivity() const override;
171 Bool_t IsRadioNuclide() const override { return kTRUE; }
172 Int_t MassNo() const { return (Int_t)fA; }
173 Int_t AtomicNo() const { return fZ; }
174 Int_t IsoNo() const { return fIso; }
175 Double_t Level() const { return fLevel; }
176 Double_t MassEx() const { return fDeltaM; }
177 Double_t HalfLife() const { return fHalfLife; }
178 Double_t NatAbun() const { return fNatAbun; }
179 const char *PJ() const { return fTitle.Data(); }
180 Double_t TH_F() const { return fTH_F; }
181 Double_t TG_F() const { return fTG_F; }
182 Double_t TH_S() const { return fTH_S; }
183 Double_t TG_S() const { return fTG_S; }
184 Double_t Status() const { return fStatus; }
185 Bool_t Stable() const { return !fDecays; }
186 TObjArray *Decays() const { return fDecays; }
187 Int_t GetNdecays() const;
188 TGeoBatemanSol *Ratio() const { return fRatio; }
189
190 // Utilities
191 Bool_t CheckDecays() const;
193 void FillPopulation(TObjArray *population, Double_t precision = 0.001, Double_t factor = 1.);
194 void Print(Option_t *option = "") const override;
195 static TGeoElementRN *ReadElementRN(const char *record, Int_t &ndecays);
196 void SavePrimitive(std::ostream &out, Option_t *option = "") override;
197
198 ClassDefOverride(TGeoElementRN, 2) // radionuclides class
199};
200
201////////////////////////////////////////////////////////////////////////////
202// //
203// TGeoDecayChannel - decay channel utility class. //
204// //
205////////////////////////////////////////////////////////////////////////////
206
207class TGeoDecayChannel : public TObject {
208private:
209 UInt_t fDecay; // Decay mode
210 Int_t fDiso; // Delta isomeric number
211 Double_t fBranchingRatio; // Branching Ratio
212 Double_t fQvalue; // Qvalue in GeV
213 TGeoElementRN *fParent; // Parent element
214 TGeoElementRN *fDaughter; // Daughter element
215public:
217 kBitMask32 = 0xffffffff,
223 kECF = BIT(5),
226 kI = BIT(8),
228 k2P = BIT(10),
229 k2N = BIT(11),
230 k2A = BIT(12),
232 kCarbon14 = BIT(14)
233 };
234 TGeoDecayChannel() : fDecay(0), fDiso(0), fBranchingRatio(0), fQvalue(0), fParent(nullptr), fDaughter(nullptr) {}
235 TGeoDecayChannel(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue)
236 : fDecay(decay),
237 fDiso(diso),
238 fBranchingRatio(branchingRatio),
239 fQvalue(qValue),
240 fParent(nullptr),
241 fDaughter(nullptr)
242 {
243 }
245 : TObject(dc),
246 fDecay(dc.fDecay),
247 fDiso(dc.fDiso),
249 fQvalue(dc.fQvalue),
250 fParent(dc.fParent),
252 {
253 }
254 ~TGeoDecayChannel() override {}
255
257
258 // Getters
259 Int_t GetIndex() const;
260 const char *GetName() const override;
261 UInt_t Decay() const { return fDecay; }
263 Double_t Qvalue() const { return fQvalue; }
264 Int_t DeltaIso() const { return fDiso; }
265 TGeoElementRN *Daughter() const { return fDaughter; }
266 TGeoElementRN *Parent() const { return fParent; }
267 static void DecayName(UInt_t decay, TString &name);
268 // Setters
269 void SetParent(TGeoElementRN *parent) { fParent = parent; }
270 void SetDaughter(TGeoElementRN *daughter) { fDaughter = daughter; }
271 // Services
272 void Print(Option_t *opt = " ") const override;
273 static TGeoDecayChannel *ReadDecay(const char *record);
274 void SavePrimitive(std::ostream &out, Option_t *option = "") override;
275 virtual void DecayShift(Int_t &dA, Int_t &dZ, Int_t &dI) const;
276
277 ClassDefOverride(TGeoDecayChannel, 1) // Decay channel for Elements
278};
279
280////////////////////////////////////////////////////////////////////////////////
281// //
282// TGeoBatemanSol -Class representing the Bateman solution for a decay branch //
283// //
284////////////////////////////////////////////////////////////////////////////////
285
286class TGeoBatemanSol : public TObject, public TAttLine, public TAttFill, public TAttMarker {
287private:
288 typedef struct {
289 Double_t cn; // Concentration for element 'i': Ni/Ntop
290 Double_t lambda; // Decay coef. for element 'i'
291 } BtCoef_t;
292 TGeoElementRN *fElem; // Referred RN element
293 TGeoElementRN *fElemTop; // Top RN element
294 Int_t fCsize; // Size of the array of coefficients
295 Int_t fNcoeff; // Number of coefficients
296 Double_t fFactor; // Constant factor that applies to all coefficients
297 Double_t fTmin; // Minimum value of the time interval
298 Double_t fTmax; // Maximum value of the time interval
299 BtCoef_t *fCoeff; //[fNcoeff] Array of coefficients
300public:
302 : TObject(),
303 TAttLine(),
304 TAttFill(),
305 TAttMarker(),
306 fElem(nullptr),
307 fElemTop(nullptr),
308 fCsize(0),
309 fNcoeff(0),
310 fFactor(1.),
311 fTmin(0.),
312 fTmax(0),
313 fCoeff(nullptr)
314 {
315 }
317 TGeoBatemanSol(const TObjArray *chain);
318 TGeoBatemanSol(const TGeoBatemanSol &other);
319 ~TGeoBatemanSol() override;
320
323
324 Double_t Concentration(Double_t time) const;
325 void Draw(Option_t *option = "") override;
326 void GetCoeff(Int_t i, Double_t &cn, Double_t &lambda) const
327 {
328 cn = fCoeff[i].cn;
329 lambda = fCoeff[i].lambda;
330 }
331 void GetRange(Double_t &tmin, Double_t &tmax) const
332 {
333 tmin = fTmin;
334 tmax = fTmax;
335 }
336 TGeoElementRN *GetElement() const { return fElem; }
338 Int_t GetNcoeff() const { return fNcoeff; }
339 void Print(Option_t *option = "") const override;
340 void SetRange(Double_t tmin = 0., Double_t tmax = 0.)
341 {
342 fTmin = tmin;
343 fTmax = tmax;
344 }
345 void SetFactor(Double_t factor) { fFactor = factor; }
346 void FindSolution(const TObjArray *array);
347 void Normalize(Double_t factor);
348
349 ClassDefOverride(TGeoBatemanSol, 1) // Solution for the Bateman equation
350};
351
352////////////////////////////////////////////////////////////////////////////
353// //
354// TGeoElemIter - iterator for decay chains. //
355// //
356////////////////////////////////////////////////////////////////////////////
357
359private:
360 const TGeoElementRN *fTop; // Top element of the iteration
361 const TGeoElementRN *fElem; // Current element
362 TObjArray *fBranch; // Current branch
363 Int_t fLevel; // Current level
364 Double_t fLimitRatio; // Minimum cumulative branching ratio
365 Double_t fRatio; // Current ratio
366
367protected:
368 TGeoElemIter() : fTop(nullptr), fElem(nullptr), fBranch(nullptr), fLevel(0), fLimitRatio(0), fRatio(0) {}
369 TGeoElementRN *Down(Int_t ibranch);
370 TGeoElementRN *Up();
371
372public:
373 TGeoElemIter(TGeoElementRN *top, Double_t limit = 1.e-4);
374 TGeoElemIter(const TGeoElemIter &iter);
375 virtual ~TGeoElemIter();
376
377 TGeoElemIter &operator=(const TGeoElemIter &iter);
380
381 TObjArray *GetBranch() const { return fBranch; }
382 const TGeoElementRN *GetTop() const { return fTop; }
383 const TGeoElementRN *GetElement() const { return fElem; }
384 Int_t GetLevel() const { return fLevel; }
385 Double_t GetRatio() const { return fRatio; }
386 virtual void Print(Option_t *option = "") const;
387 void SetLimitRatio(Double_t limit) { fLimitRatio = limit; }
388
389 ClassDef(TGeoElemIter, 0) // Iterator for radionuclide chains.
390};
391
392////////////////////////////////////////////////////////////////////////////
393// //
394// TGeoElementTable - table of elements //
395// //
396////////////////////////////////////////////////////////////////////////////
397
398class TGeoElementTable : public TObject {
399private:
400 // data members
401 Int_t fNelements; // number of elements
402 Int_t fNelementsRN; // number of RN elements
403 Int_t fNisotopes; // number of isotopes
404 TObjArray *fList; // list of elements
405 TObjArray *fListRN; // list of RN elements
406 TObjArray *fIsotopes; // list of user-defined isotopes
407 // Map of radionuclides
408 typedef std::map<Int_t, TGeoElementRN *> ElementRNMap_t;
409 typedef ElementRNMap_t::iterator ElementRNMapIt_t;
410 ElementRNMap_t fElementsRN; //! map of RN elements with ENDF key
411
412protected:
415
416public:
417 // constructors
419 TGeoElementTable(Int_t nelements);
420 // destructor
421 ~TGeoElementTable() override;
422 // methods
423
425 void AddElement(const char *name, const char *title, Int_t z, Double_t a);
426 void AddElement(const char *name, const char *title, Int_t z, Int_t n, Double_t a);
427 void AddElement(TGeoElement *elem);
428 void AddElementRN(TGeoElementRN *elem);
429 void AddIsotope(TGeoIsotope *isotope);
431 void ImportElementsRN();
432 Bool_t CheckTable() const;
433 TGeoElement *FindElement(const char *name) const;
434 TGeoIsotope *FindIsotope(const char *name) const;
436 TGeoElementRN *GetElementRN(Int_t ENDFcode) const;
437 TGeoElementRN *GetElementRN(Int_t a, Int_t z, Int_t iso = 0) const;
438 TObjArray *GetElementsRN() const { return fListRN; }
441
442 Int_t GetNelements() const { return fNelements; }
444 void ExportElementsRN(const char *filename = "");
445 void Print(Option_t *option = "") const override;
446
447 ClassDefOverride(TGeoElementTable, 4) // table of elements
448};
449
450#endif
#define a(i)
Definition RSha256.hxx:99
bool Bool_t
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
unsigned int UInt_t
Definition RtypesCore.h:46
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
double Double_t
Definition RtypesCore.h:59
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
#define ClassDef(name, id)
Definition Rtypes.h:337
#define BIT(n)
Definition Rtypes.h:85
#define ClassDefOverride(name, id)
Definition Rtypes.h:341
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
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.
Int_t GetNcoeff() const
Double_t fFactor
BtCoef_t * fCoeff
void GetCoeff(Int_t i, Double_t &cn, Double_t &lambda) const
~TGeoBatemanSol() override
Destructor.
void SetRange(Double_t tmin=0., Double_t tmax=0.)
void FindSolution(const TObjArray *array)
Find the solution for the Bateman equations corresponding to the decay chain described by an array en...
TGeoElementRN * fElem
TGeoElementRN * fElemTop
void GetRange(Double_t &tmin, Double_t &tmax) const
TGeoBatemanSol & operator=(const TGeoBatemanSol &other)
Assignment.
void SetFactor(Double_t factor)
TGeoElementRN * GetTopElement() const
void Normalize(Double_t factor)
Normalize all coefficients with a given factor.
TGeoElementRN * GetElement() const
TGeoBatemanSol & operator+=(const TGeoBatemanSol &other)
Addition of other solution.
void Print(Option_t *option="") const override
Print concentration evolution.
A decay channel for a radionuclide.
~TGeoDecayChannel() override
void SetParent(TGeoElementRN *parent)
Int_t DeltaIso() const
TGeoElementRN * fParent
Double_t Qvalue() const
TGeoElementRN * Daughter() const
UInt_t Decay() const
TGeoDecayChannel(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue)
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save primitive for decays.
static TGeoDecayChannel * ReadDecay(const char *record)
Create element from line record.
TGeoElementRN * Parent() const
void Print(Option_t *opt=" ") const override
Prints decay info.
const char * GetName() const override
Returns name of decay.
TGeoElementRN * fDaughter
Double_t BranchingRatio() const
Double_t fBranchingRatio
void SetDaughter(TGeoElementRN *daughter)
TGeoDecayChannel & operator=(const TGeoDecayChannel &dc)
Assignment.
static void DecayName(UInt_t decay, TString &name)
Returns decay name.
TGeoDecayChannel(const TGeoDecayChannel &dc)
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.
Iterator for decay branches.
virtual void Print(Option_t *option="") const
Print info about the current decay branch.
Double_t fRatio
void SetLimitRatio(Double_t limit)
TObjArray * GetBranch() const
Double_t GetRatio() const
const TGeoElementRN * fElem
TObjArray * fBranch
TGeoElementRN * Next()
Return next element.
TGeoElemIter & operator=(const TGeoElemIter &iter)
Assignment.
virtual ~TGeoElemIter()
Destructor.
TGeoElementRN * operator()()
() operator.
const TGeoElementRN * fTop
Double_t fLimitRatio
TGeoElementRN * Up()
Go upwards from the current location until the next branching, then down.
const TGeoElementRN * GetElement() const
TGeoElementRN * Down(Int_t ibranch)
Go downwards from current level via ibranch as low in the tree as possible.
const TGeoElementRN * GetTop() const
Int_t GetLevel() const
Class representing a radionuclidevoid TGeoManager::SetDefaultRootUnits() { if ( fgDefaultUnits == kRo...
Double_t fNatAbun
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
void AddDecay(Int_t decay, Int_t diso, Double_t branchingRatio, Double_t qValue)
Adds a decay mode for this element.
Double_t fHalfLife
TObjArray * fDecays
Double_t GetSpecificActivity() const override
Get the activity in Bq of a gram of material made from this element.
void Print(Option_t *option="") const override
Print info about the element;.
Double_t TG_F() const
Double_t Level() const
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save primitive for RN elements.
Int_t AtomicNo() const
Double_t fTH_S
const char * PJ() const
Int_t MassNo() const
Double_t fLevel
Int_t IsoNo() const
TGeoBatemanSol * fRatio
Double_t HalfLife() const
Double_t fDeltaM
Int_t DecayResult(TGeoDecayChannel *dc) const
Returns ENDF code of decay result.
TGeoBatemanSol * Ratio() const
Double_t MassEx() const
TObjArray * Decays() const
Bool_t Stable() const
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 IsRadioNuclide() const override
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
Double_t TH_F() const
~TGeoElementRN() override
Destructor.
Double_t fTG_F
Double_t Status() const
Double_t fTH_F
static Int_t ENDF(Int_t a, Int_t z, Int_t iso)
void ResetRatio()
Clears the existing ratio.
Double_t fTG_S
Double_t NatAbun() const
Int_t ENDFCode() const override
Table of elements.
Int_t GetNelementsRN() const
TGeoElementTable & operator=(const TGeoElementTable &)
assignment operator
Bool_t HasRNElements() const
ElementRNMap_t::iterator ElementRNMapIt_t
void ExportElementsRN(const char *filename="")
Export radionuclides in a file.
TObjArray * fListRN
void AddIsotope(TGeoIsotope *isotope)
Add isotope to the table.
ElementRNMap_t fElementsRN
TGeoElementRN * GetElementRN(Int_t ENDFcode) const
Retrieve a radionuclide by ENDF code.
~TGeoElementTable() override
destructor
void AddElementRN(TGeoElementRN *elem)
Add a radionuclide to the table and map it.
Bool_t HasDefaultElements() const
TObjArray * fList
TObjArray * fIsotopes
Bool_t CheckTable() const
Checks status of element table.
void Print(Option_t *option="") const override
Print table of elements.
void ImportElementsRN()
Creates the list of radionuclides.
std::map< Int_t, TGeoElementRN * > ElementRNMap_t
TGeoElement * GetElement(Int_t z)
void AddElement(const char *name, const char *title, Int_t z, Double_t a)
Add an element to the table. Obsolete.
TObjArray * GetElementsRN() const
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
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:36
Double_t fA
Definition TGeoElement.h:43
Int_t N() const
Definition TGeoElement.h:69
virtual Double_t GetSpecificActivity() const
Definition TGeoElement.h:79
Int_t fNisotopes
Definition TGeoElement.h:42
Double_t fRadTsai
Definition TGeoElement.h:47
Bool_t IsDefined() const
Definition TGeoElement.h:81
TGeoElement()
Default constructor.
Double_t A() const
Definition TGeoElement.h:71
void SetDefined(Bool_t flag=kTRUE)
Definition TGeoElement.h:85
virtual Bool_t IsRadioNuclide() const
Definition TGeoElement.h:82
void ComputeDerivedQuantities()
Calculate properties for an atomic number.
void Print(Option_t *option="") const override
Print this isotope.
Double_t Neff() const
Returns effective number of nucleons.
Int_t Z() const
Definition TGeoElement.h:68
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:46
virtual Int_t ENDFCode() const
Definition TGeoElement.h:67
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:44
TGeoElement(const TGeoElement &other)=delete
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:89
Int_t GetNisotopes() const
Definition TGeoElement.h:73
Double_t * fAbundances
Definition TGeoElement.h:45
Double_t GetfRadTsai() const
Definition TGeoElement.h:91
Bool_t HasIsotopes() const
Definition TGeoElement.h:80
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:86
TGeoIsotope * GetIsotope(Int_t i) const
Return i-th isotope in the element.
Bool_t IsUsed() const
Definition TGeoElement.h:83
~TGeoElement() override
destructor
Double_t fA
~TGeoIsotope() override
TGeoIsotope()
Dummy I/O constructor.
Int_t GetZ() const
Int_t GetN() const
Double_t GetA() const
static TGeoIsotope * FindIsotope(const char *name)
Find existing isotope by name.
void Print(Option_t *option="") const override
Print this isotope.
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:31
TObject * At(Int_t idx) const override
Definition TObjArray.h:164
Mother of all ROOT objects.
Definition TObject.h:41
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:201
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:780
Basic string class.
Definition TString.h:139
const char * Data() const
Definition TString.h:378
const Int_t n
Definition legend1.C:16
th1 Draw()