| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
>> 25 //
>> 26 //
>> 27 // $Id$
>> 28 //
25 29
26 //-------------------------------------------- 30 //---------------------------------------------------------------------------
27 // 31 //
28 // ClassName: G4Material 32 // ClassName: G4Material
29 // 33 //
30 // Description: Contains material properties 34 // Description: Contains material properties
31 // 35 //
32 // Class description: 36 // Class description:
33 // 37 //
34 // Is used to define the material composition 38 // Is used to define the material composition of Geant4 volumes.
35 // A G4Material is always made of G4Elements. << 39 // A G4Material is always made of G4Elements. It should has the name,
36 // the list of G4Elements, material density, m << 40 // the list of G4Elements, material density, material state, temperature,
37 // pressure. Other parameters are optional and << 41 // pressure. Other parameters are optional and may be set by the user code
38 // or computed at initialisation. << 42 // or computed at initialisation.
39 // << 43 //
40 // There is several ways to construct G4Materi 44 // There is several ways to construct G4Material:
41 // - from single element; 45 // - from single element;
42 // - from a list of components (elements or 46 // - from a list of components (elements or other materials);
43 // - from internal Geant4 database of materi 47 // - from internal Geant4 database of materials
44 // 48 //
45 // A collection of constituent Elements/Materi << 49 // A collection of constituent Elements/Materials should be defined
46 // with specified weights by fractional mass o 50 // with specified weights by fractional mass or atom counts (only for Elements).
47 // 51 //
48 // Quantities, with physical meaning or not, w << 52 // Quantities, with physical meaning or not, which are constant in a given
49 // material are computed and stored here as De 53 // material are computed and stored here as Derived data members.
50 // 54 //
51 // The class contains as a private static memb 55 // The class contains as a private static member the Table of defined
52 // materials (an ordered vector of materials). 56 // materials (an ordered vector of materials).
53 // 57 //
54 // It is strongly not recommended to delete ma 58 // It is strongly not recommended to delete materials in user code.
55 // All materials will be deleted automatically 59 // All materials will be deleted automatically at the end of Geant4 session.
56 // 60 //
>> 61
>> 62 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 63
57 // 10-07-96, new data members added by L.Urban 64 // 10-07-96, new data members added by L.Urban
58 // 12-12-96, new data members added by L.Urban 65 // 12-12-96, new data members added by L.Urban
59 // 20-01-97, aesthetic rearrangement. RadLengt 66 // 20-01-97, aesthetic rearrangement. RadLength calculation modified
60 // Data members Zeff and Aeff REMOVE 67 // Data members Zeff and Aeff REMOVED (i.e. passed to the Elements).
61 // (local definition of Zeff in Dens 68 // (local definition of Zeff in DensityEffect and FluctModel...)
62 // Vacuum defined as a G4State. Mixt << 69 // Vacuum defined as a G4State. Mixture flag removed, M.Maire
63 // 29-01-97, State=Vacuum automatically set de 70 // 29-01-97, State=Vacuum automatically set density=0 in the contructors.
64 // Subsequent protections have been << 71 // Subsequent protections have been put in the calculation of
65 // MeanExcEnergy, ShellCorrectionVec 72 // MeanExcEnergy, ShellCorrectionVector, DensityEffect, M.Maire
66 // 20-03-97, corrected initialization of point 73 // 20-03-97, corrected initialization of pointers, M.Maire
67 // 10-06-97, new data member added by V.Grichi 74 // 10-06-97, new data member added by V.Grichine (fSandiaPhotoAbsCof)
68 // 27-06-97, new function GetElement(int), M.M 75 // 27-06-97, new function GetElement(int), M.Maire
69 // 24-02-98, fFractionVector become fMassFract 76 // 24-02-98, fFractionVector become fMassFractionVector
70 // 28-05-98, kState=kVacuum removed: << 77 // 28-05-98, kState=kVacuum removed:
71 // The vacuum is an ordinary gas vit 78 // The vacuum is an ordinary gas vith very low density, M.Maire
72 // 12-06-98, new method AddMaterial() allowing 79 // 12-06-98, new method AddMaterial() allowing mixture of materials, M.Maire
73 // 09-07-98, Ionisation parameters removed fro 80 // 09-07-98, Ionisation parameters removed from the class, M.Maire
74 // 04-08-98, new method GetMaterial(materialNa 81 // 04-08-98, new method GetMaterial(materialName), M.Maire
75 // 05-10-98, change name: NumDensity -> NbOfAt 82 // 05-10-98, change name: NumDensity -> NbOfAtomsPerVolume
76 // 18-11-98, SandiaTable interface modified. 83 // 18-11-98, SandiaTable interface modified.
77 // 19-07-99, new data member (chemicalFormula) 84 // 19-07-99, new data member (chemicalFormula) added by V.Ivanchenko
78 // 12-03-01, G4bool fImplicitElement (mma) 85 // 12-03-01, G4bool fImplicitElement (mma)
79 // 30-03-01, suppression of the warning messag 86 // 30-03-01, suppression of the warning message in GetMaterial
80 // 17-07-01, migration to STL. M. Verderi. 87 // 17-07-01, migration to STL. M. Verderi.
81 // 14-09-01, Suppression of the data member fI 88 // 14-09-01, Suppression of the data member fIndexInTable
82 // 31-10-01, new function SetChemicalFormula() 89 // 31-10-01, new function SetChemicalFormula() (mma)
83 // 26-02-02, fIndexInTable renewed 90 // 26-02-02, fIndexInTable renewed
84 // 06-08-02, remove constructors with Chemical 91 // 06-08-02, remove constructors with ChemicalFormula (mma)
85 // 15-11-05, GetMaterial(materialName, G4bool 92 // 15-11-05, GetMaterial(materialName, G4bool warning=true)
86 // 13-04-12, std::map<G4Material*,G4double> fM 93 // 13-04-12, std::map<G4Material*,G4double> fMatComponents (mma)
87 // 21-04-12, fMassOfMolecule (mma) 94 // 21-04-12, fMassOfMolecule (mma)
88 95
>> 96 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 97
89 #ifndef G4MATERIAL_HH 98 #ifndef G4MATERIAL_HH
90 #define G4MATERIAL_HH 1 99 #define G4MATERIAL_HH 1
91 100
>> 101 #include <vector>
>> 102 #include <map>
>> 103 #include <CLHEP/Units/PhysicalConstants.h>
>> 104
>> 105 #include "globals.hh"
>> 106 #include "G4ios.hh"
92 #include "G4Element.hh" 107 #include "G4Element.hh"
93 #include "G4ElementVector.hh" <<
94 #include "G4IonisParamMat.hh" <<
95 #include "G4MaterialPropertiesTable.hh" 108 #include "G4MaterialPropertiesTable.hh"
96 #include "G4MaterialTable.hh" << 109 #include "G4IonisParamMat.hh"
97 #include "G4SandiaTable.hh" 110 #include "G4SandiaTable.hh"
98 #include "G4ios.hh" << 111 #include "G4ElementVector.hh"
99 #include "globals.hh" << 112 #include "G4MaterialTable.hh"
100 << 113 #include "G4Threading.hh"
101 #include <CLHEP/Units/PhysicalConstants.h> <<
102 114
103 #include <map> << 115 enum G4State { kStateUndefined = 0, kStateSolid, kStateLiquid, kStateGas };
104 #include <vector> <<
105 116
106 enum G4State << 117 static const G4double NTP_Temperature = 293.15;
107 { <<
108 kStateUndefined = 0, <<
109 kStateSolid, <<
110 kStateLiquid, <<
111 kStateGas <<
112 }; <<
113 118
114 static const G4double NTP_Temperature = 293.15 << 119 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
115 120
116 class G4Material 121 class G4Material
117 { 122 {
118 public: // with description << 123 public: // with description
>> 124 //
119 // Constructor to create a material from sin 125 // Constructor to create a material from single element
120 G4Material(const G4String& name, // its nam << 126 //
121 G4double z, // atomic number << 127 G4Material(const G4String& name, //its name
122 G4double a, // mass of mole << 128 G4double z, //atomic number
123 G4double density, // density << 129 G4double a, //mass of mole
124 G4State state = kStateUndefined, // solid << 130 G4double density, //density
125 G4double temp = NTP_Temperature, // tempe << 131 G4State state = kStateUndefined, //solid,gas
126 G4double pressure = CLHEP::STP_Pressure); << 132 G4double temp = NTP_Temperature, //temperature
>> 133 G4double pressure = CLHEP::STP_Pressure); //pressure
127 134
>> 135 //
128 // Constructor to create a material from a c 136 // Constructor to create a material from a combination of elements
129 // and/or materials subsequently added via A 137 // and/or materials subsequently added via AddElement and/or AddMaterial
130 G4Material(const G4String& name, // its nam << 138 //
131 G4double density, // density << 139 G4Material(const G4String& name, //its name
132 G4int nComponents, // nbOfComponents << 140 G4double density, //density
133 G4State state = kStateUndefined, // solid << 141 G4int nComponents, //nbOfComponents
134 G4double temp = NTP_Temperature, // tempe << 142 G4State state = kStateUndefined, //solid,gas
135 G4double pressure = CLHEP::STP_Pressure); << 143 G4double temp = NTP_Temperature, //temperature
>> 144 G4double pressure = CLHEP::STP_Pressure); //pressure
136 145
>> 146 //
137 // Constructor to create a material from the 147 // Constructor to create a material from the base material
138 G4Material(const G4String& name, // its nam << 148 //
139 G4double density, // density << 149 G4Material(const G4String& name, //its name
140 const G4Material* baseMaterial, // base m << 150 G4double density, //density
141 G4State state = kStateUndefined, // solid << 151 const G4Material* baseMaterial, //base material
142 G4double temp = NTP_Temperature, // tempe << 152 G4State state = kStateUndefined, //solid,gas
143 G4double pressure = CLHEP::STP_Pressure); << 153 G4double temp = NTP_Temperature, //temperature
144 << 154 G4double pressure = CLHEP::STP_Pressure); //pressure
145 virtual ~G4Material(); <<
146 <<
147 // These methods allow customisation of corr <<
148 // computations. Free electron density above <<
149 // is a conductor. Computation of density ef <<
150 // may be more accurate but require extra co <<
151 void SetChemicalFormula(const G4String& chF) <<
152 void SetFreeElectronDensity(G4double val); <<
153 void ComputeDensityEffectOnFly(G4bool val); <<
154 <<
155 G4Material(const G4Material&) = delete; <<
156 const G4Material& operator=(const G4Material <<
157 155
>> 156 //
158 // Add an element, giving number of atoms 157 // Add an element, giving number of atoms
159 void AddElementByNumberOfAtoms(const G4Eleme << 158 //
160 inline void AddElement(G4Element* elm, G4int << 159 void AddElement(G4Element* element, //the element
161 << 160 G4int nAtoms); //nb of atoms in
>> 161 // a molecule
>> 162 //
162 // Add an element or material, giving fracti 163 // Add an element or material, giving fraction of mass
163 void AddElementByMassFraction(const G4Elemen << 164 //
164 inline void AddElement(G4Element* elm, G4dou << 165 void AddElement (G4Element* element , //the element
165 << 166 G4double fraction); //fractionOfMass
166 void AddMaterial(G4Material* material, G4dou << 167
>> 168 void AddMaterial(G4Material* material, //the material
>> 169 G4double fraction); //fractionOfMass
>> 170
>> 171
>> 172 virtual ~G4Material();
>> 173
>> 174 inline void SetChemicalFormula (const G4String& chF) {fChemicalFormula=chF;}
167 175
168 // 176 //
169 // retrieval methods 177 // retrieval methods
170 // << 178 //
171 inline const G4String& GetName() const { ret << 179 inline const G4String& GetName() const {return fName;}
172 inline const G4String& GetChemicalFormula() << 180 inline const G4String& GetChemicalFormula() const {return fChemicalFormula;}
173 inline G4double GetFreeElectronDensity() con << 181 inline G4double GetDensity() const {return fDensity;}
174 inline G4double GetDensity() const { return << 182 inline G4State GetState() const {return fState;}
175 inline G4State GetState() const { return fSt << 183 inline G4double GetTemperature() const {return fTemp;}
176 inline G4double GetTemperature() const { ret << 184 inline G4double GetPressure() const {return fPressure;}
177 inline G4double GetPressure() const { return << 185
178 << 186 //number of elements constituing this material:
179 // number of elements constituing this mater << 187 inline size_t GetNumberOfElements() const {return fNumberOfElements;}
180 inline std::size_t GetNumberOfElements() con << 188
181 << 189 //vector of pointers to elements constituing this material:
182 // vector of pointers to elements constituin << 190 inline const
183 inline const G4ElementVector* GetElementVect << 191 G4ElementVector* GetElementVector() const {return theElementVector;}
184 << 192
185 // vector of fractional mass of each element << 193 //vector of fractional mass of each element:
186 inline const G4double* GetFractionVector() c << 194 inline const
187 << 195 G4double* GetFractionVector() const {return fMassFractionVector;}
188 // vector of atom count of each element: << 196
189 inline const G4int* GetAtomsVector() const { << 197 //vector of atom count of each element:
190 << 198 inline const
191 // return a pointer to an element, given its << 199 G4int* GetAtomsVector() const {return fAtomsVector;}
192 inline const G4Element* GetElement(G4int iel << 200
193 << 201 //return a pointer to an element, given its index in the material:
194 // vector of nb of atoms per volume of each << 202 inline const
195 inline const G4double* GetVecNbOfAtomsPerVol << 203 G4Element* GetElement(G4int iel) const {return (*theElementVector)[iel];}
196 // total number of atoms per volume: << 204
197 inline G4double GetTotNbOfAtomsPerVolume() c << 205 //vector of nb of atoms per volume of each element in this material:
198 // total number of electrons per volume: << 206 inline const
199 inline G4double GetTotNbOfElectPerVolume() c << 207 G4double* GetVecNbOfAtomsPerVolume() const {return VecNbOfAtomsPerVolume;}
200 << 208 //total number of atoms per volume:
201 // obsolete names (5-10-98) see the 2 functi << 209 inline
202 inline const G4double* GetAtomicNumDensityVe << 210 G4double GetTotNbOfAtomsPerVolume() const {return TotNbOfAtomsPerVolume;}
203 inline G4double GetElectronDensity() const { << 211 //total number of electrons per volume:
204 << 212 inline
205 // Radiation length: << 213 G4double GetTotNbOfElectPerVolume() const {return TotNbOfElectPerVolume;}
206 inline G4double GetRadlen() const { return f << 214
207 << 215 //obsolete names (5-10-98) see the 2 functions above
208 // Nuclear interaction length << 216 inline const
209 inline G4double GetNuclearInterLength() cons << 217 G4double* GetAtomicNumDensityVector() const {return VecNbOfAtomsPerVolume;}
210 << 218 inline G4double GetElectronDensity() const {return TotNbOfElectPerVolume;}
>> 219
>> 220 // Radiation length:
>> 221 inline G4double GetRadlen() const {return fRadlen;}
>> 222
>> 223 // Nuclear interaction length
>> 224 inline G4double GetNuclearInterLength() const {return fNuclInterLen;}
>> 225
211 // ionisation parameters: 226 // ionisation parameters:
212 inline G4IonisParamMat* GetIonisation() cons << 227 inline G4IonisParamMat* GetIonisation() const {return fIonisation;}
213 << 228
214 // Sandia table: 229 // Sandia table:
215 inline G4SandiaTable* GetSandiaTable() const << 230 inline G4SandiaTable* GetSandiaTable() const {return fSandiaTable;}
216 231
217 // Base material: 232 // Base material:
218 inline const G4Material* GetBaseMaterial() c << 233 inline
219 << 234 const G4Material* GetBaseMaterial() const {return fBaseMaterial;}
>> 235
220 // material components: 236 // material components:
221 inline const std::map<G4Material*, G4double> << 237 inline
222 << 238 const std::map<G4Material*,G4double>& GetMatComponents() const
>> 239 {return fMatComponents;}
>> 240
223 // for chemical compound 241 // for chemical compound
224 inline G4double GetMassOfMolecule() const { << 242 inline
225 << 243 G4double GetMassOfMolecule() const {return fMassOfMolecule;}
>> 244
226 // meaningful only for single material: 245 // meaningful only for single material:
227 G4double GetZ() const; 246 G4double GetZ() const;
228 G4double GetA() const; 247 G4double GetA() const;
229 248
230 // the MaterialPropertiesTable (if any) atta << 249 //the MaterialPropertiesTable (if any) attached to this material:
231 void SetMaterialPropertiesTable(G4MaterialPr 250 void SetMaterialPropertiesTable(G4MaterialPropertiesTable* anMPT);
232 << 251
233 inline G4MaterialPropertiesTable* GetMateria 252 inline G4MaterialPropertiesTable* GetMaterialPropertiesTable() const
234 { << 253 {return fMaterialPropertiesTable;}
235 return fMaterialPropertiesTable; <<
236 } <<
237 <<
238 // the index of this material in the Table: <<
239 inline std::size_t GetIndex() const { return <<
240 254
241 // the static Table of Materials: 255 // the static Table of Materials:
>> 256 //
242 static G4MaterialTable* GetMaterialTable(); 257 static G4MaterialTable* GetMaterialTable();
>> 258
>> 259 static size_t GetNumberOfMaterials();
>> 260
>> 261 //the index of this material in the Table:
>> 262 inline size_t GetIndex() const {return fIndexInTable;}
>> 263
>> 264 //return pointer to a material, given its name:
>> 265 static G4Material* GetMaterial(const G4String& name, G4bool warning=true);
>> 266
>> 267 //
>> 268 //printing methods
>> 269 //
>> 270 friend std::ostream& operator<<(std::ostream&, const G4Material*);
>> 271 friend std::ostream& operator<<(std::ostream&, const G4Material&);
>> 272 friend std::ostream& operator<<(std::ostream&, G4MaterialTable);
>> 273
>> 274 G4Material(__void__&);
>> 275 // Fake default constructor for usage restricted to direct object
>> 276 // persistency for clients requiring preallocation of memory for
>> 277 // persistifiable objects.
243 278
244 static std::size_t GetNumberOfMaterials(); << 279 inline void SetName (const G4String& name) {fName=name;}
245 <<
246 // return pointer to a material, given its <<
247 static G4Material* GetMaterial(const G4Strin <<
248 <<
249 // return pointer to a simple material, giv <<
250 static G4Material* GetMaterial(G4double z, G <<
251 <<
252 // return pointer to a composit material, g <<
253 static G4Material* GetMaterial(std::size_t n <<
254 <<
255 // printing methods <<
256 friend std::ostream& operator<<(std::ostream <<
257 friend std::ostream& operator<<(std::ostream <<
258 friend std::ostream& operator<<(std::ostream <<
259 <<
260 inline void SetName(const G4String& name) { <<
261 280
262 virtual G4bool IsExtended() const; 281 virtual G4bool IsExtended() const;
263 282
264 // operators << 283 private:
265 G4bool operator==(const G4Material&) const = <<
266 G4bool operator!=(const G4Material&) const = <<
267 284
268 private: << 285 // operators
269 void InitializePointers(); << 286 G4int operator==(const G4Material&) const = delete;
>> 287 G4int operator!=(const G4Material&) const = delete;
>> 288 G4Material(const G4Material&) = delete;
>> 289 const G4Material& operator=(const G4Material&) = delete;
270 290
>> 291 void InitializePointers();
>> 292
271 // Header routine for all derived quantities 293 // Header routine for all derived quantities
272 void ComputeDerivedQuantities(); 294 void ComputeDerivedQuantities();
273 295
274 // Compute Radiation length 296 // Compute Radiation length
275 void ComputeRadiationLength(); 297 void ComputeRadiationLength();
276 << 298
277 // Compute Nuclear interaction length 299 // Compute Nuclear interaction length
278 void ComputeNuclearInterLength(); 300 void ComputeNuclearInterLength();
279 301
280 // Copy pointers of base material 302 // Copy pointers of base material
281 void CopyPointersOfBaseMaterial(); 303 void CopyPointersOfBaseMaterial();
282 << 304
283 void FillVectors(); << 305 private:
284 <<
285 G4bool IsLocked(); <<
286 <<
287 const G4Material* fBaseMaterial; // Pointer <<
288 G4MaterialPropertiesTable* fMaterialProperti <<
289 306
290 // 307 //
291 // General atomic properties defined in cons << 308 // Basic data members ( To define a material)
292 // computed from the basic data members <<
293 // 309 //
>> 310 G4String fName; // Material name
>> 311 G4String fChemicalFormula; // Material chemical formula
>> 312 G4double fDensity; // Material density
>> 313
>> 314 G4State fState; // Material state (determined
>> 315 // internally based on density)
>> 316 G4double fTemp; // Temperature (defaults: STP)
>> 317 G4double fPressure; // Pressure (defaults: STP)
>> 318
>> 319 G4int maxNbComponents; // totalNbOfComponentsInTheMaterial
>> 320 G4int fArrayLength; // the length of fAtomsVector
>> 321 G4int fNumberOfComponents; // Nb of components declared so far
>> 322
>> 323 G4int fNumberOfElements; // Nb of Elements in the material
>> 324 G4ElementVector* theElementVector; // vector of constituent Elements
>> 325 G4double* fMassFractionVector; // composition by fractional mass
>> 326 G4int* fAtomsVector; // composition by atom count
294 327
295 G4ElementVector* theElementVector; // vecto << 328 G4MaterialPropertiesTable* fMaterialPropertiesTable;
296 G4int* fAtomsVector; // composition by atom <<
297 G4double* fMassFractionVector; // compositi <<
298 G4double* fVecNbOfAtomsPerVolume; // number <<
299 <<
300 G4IonisParamMat* fIonisation; // ionisation <<
301 G4SandiaTable* fSandiaTable; // Sandia tabl <<
302 <<
303 G4double fDensity; // Material density <<
304 G4double fFreeElecDensity; // Free electron <<
305 G4double fTemp; // Temperature (defaults: S <<
306 G4double fPressure; // Pressure (default <<
307 <<
308 G4double fTotNbOfAtomsPerVolume; // Total n <<
309 G4double fTotNbOfElectPerVolume; // Total n <<
310 G4double fRadlen; // Radiation length <<
311 G4double fNuclInterLen; // Nuclear interact <<
312 G4double fMassOfMolecule; // Correct for ma <<
313 <<
314 G4State fState; // Material state <<
315 std::size_t fIndexInTable; // Index in the <<
316 G4int fNumberOfElements; // Number of G4Ele <<
317 <<
318 // Class members used only at initialisation <<
319 G4int fNbComponents; // Number of component <<
320 G4int fIdxComponent; // Index of a new comp <<
321 G4bool fMassFraction; // Flag of the method <<
322 <<
323 // For composites built <<
324 std::vector<G4int>* fAtoms = nullptr; <<
325 std::vector<G4double>* fElmFrac = nullptr; <<
326 std::vector<const G4Element*>* fElm = nullpt <<
327 329
328 // For composites built via AddMaterial() << 330 static
329 std::map<G4Material*, G4double> fMatComponen << 331 G4MaterialTable theMaterialTable; // the material table
>> 332 size_t fIndexInTable; // the position in the table
330 333
331 G4String fName; // Material name << 334 //
332 G4String fChemicalFormula; // Material chem << 335 // Derived data members (computed from the basic data members)
>> 336 //
>> 337 // some general atomic properties
>> 338
>> 339 G4double* VecNbOfAtomsPerVolume; // vector of nb of atoms per volume
>> 340 G4double TotNbOfAtomsPerVolume; // total nb of atoms per volume
>> 341 G4double TotNbOfElectPerVolume; // total nb of electrons per volume
>> 342 G4double fRadlen; // Radiation length
>> 343 G4double fNuclInterLen; // Nuclear interaction length
>> 344
>> 345 G4IonisParamMat* fIonisation; // ionisation parameters
>> 346 G4SandiaTable* fSandiaTable; // Sandia table
>> 347
>> 348 // utilities
>> 349 //
>> 350 const G4Material* fBaseMaterial; // Pointer to the base material
>> 351 G4double fMassOfMolecule; // for materials built by atoms count
>> 352 std::map<G4Material*,G4double> fMatComponents; // for composites built via
>> 353 // AddMaterial()
>> 354 #ifdef G4MULTITHREADED
>> 355 static G4Mutex materialMutex;
>> 356 #endif
333 }; 357 };
>> 358
>> 359 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
334 360
335 #endif 361 #endif
336 362