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 9.4.p2)


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