Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/materials/include/G4Material.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /materials/include/G4Material.hh (Version 11.3.0) and /materials/include/G4Material.hh (Version 1.1)


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