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