Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/materials/include/G4NistMaterialBuilder.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/G4NistMaterialBuilder.hh (Version 11.3.0) and /materials/include/G4NistMaterialBuilder.hh (Version 9.1)


  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 //                                                 25 //
                                                   >>  26 // $Id: G4NistMaterialBuilder.hh,v 1.12 2007/10/30 10:05:52 vnivanch Exp $
                                                   >>  27 // GEANT4 tag $Name: geant4-09-01 $
 26                                                    28 
 27 #ifndef G4NistMaterialBuilder_h                    29 #ifndef G4NistMaterialBuilder_h
 28 #define G4NistMaterialBuilder_h 1                  30 #define G4NistMaterialBuilder_h 1
 29                                                    31 
 30 //--------------------------------------------     32 //---------------------------------------------------------------------------
 31 //                                                 33 //
 32 // ClassName:   G4NistMaterialBuilder              34 // ClassName:   G4NistMaterialBuilder
 33 //                                                 35 //
 34 // Description: Utility class to hold and mani     36 // Description: Utility class to hold and manipulate G4Materials
 35 //                                                 37 //
 36 // Author:      V.Ivanchenko 21.11.2004            38 // Author:      V.Ivanchenko 21.11.2004
 37 //                                                 39 //
 38 // Modifications:                                  40 // Modifications:
 39 // 31.10.05 Add chemical effect and gas proper     41 // 31.10.05 Add chemical effect and gas properties (V.Ivanchenko)
 40 // 27.02.06 V.Ivanchneko add ConstructNewGasMa     42 // 27.02.06 V.Ivanchneko add ConstructNewGasMaterial
 41 // 11.05.06 V.Ivanchneko add warning flag to F     43 // 11.05.06 V.Ivanchneko add warning flag to FindOrBuildMaterial method
 42 // 27.07.06 V.Ivanchneko set defaul warning=tr     44 // 27.07.06 V.Ivanchneko set defaul warning=true for FindOrBuildMaterial
 43 // 27.07.07 V.Ivanchneko add matIndex vector t     45 // 27.07.07 V.Ivanchneko add matIndex vector to control built materials
 44 // 28.07.07 V.Ivanchneko add BuildMaterial met     46 // 28.07.07 V.Ivanchneko add BuildMaterial method using Nist index
 45 // 29.04.10 V.Ivanchneko add GetMeanIonisation << 
 46 // 09.02.12 P.Gumplinger add ConstructNewIdeal << 
 47 //                                                 47 //
 48 //--------------------------------------------     48 //----------------------------------------------------------------------------
 49 //                                                 49 //
 50 // Class Description:                              50 // Class Description:
 51 //                                                 51 //
 52 // Element data from the NIST DB on Atomic Wei     52 // Element data from the NIST DB on Atomic Weights and Isotope Compositions
 53 // http://physics.nist.gov/PhysRefData/Composi     53 // http://physics.nist.gov/PhysRefData/Compositions/index.html
 54 //                                                 54 //
 55                                                    55 
 56 #include "G4Material.hh"                       <<  56 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 57 #include "globals.hh"                          << 
 58                                                << 
 59 #include <CLHEP/Units/PhysicalConstants.h>     << 
 60                                                    57 
                                                   >>  58 #include "globals.hh"
                                                   >>  59 #include "G4Material.hh"
 61 #include <vector>                                  60 #include <vector>
 62                                                    61 
                                                   >>  62 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >>  63 
 63 class G4NistElementBuilder;                        64 class G4NistElementBuilder;
 64                                                    65 
 65 class G4NistMaterialBuilder                        66 class G4NistMaterialBuilder
 66 {                                                  67 {
 67  public:                                       <<  68 public:
 68   G4NistMaterialBuilder(G4NistElementBuilder*, << 
 69                                                << 
 70   ~G4NistMaterialBuilder() = default;          << 
 71                                                    69 
                                                   >>  70   G4NistMaterialBuilder(G4NistElementBuilder*, G4int verb=0);
                                                   >>  71       
                                                   >>  72   ~G4NistMaterialBuilder();
                                                   >>  73  
 72   // Find or build a G4Material by name, from      74   // Find or build a G4Material by name, from dataBase
 73   inline G4Material* FindMaterial(const G4Stri <<  75   //
 74   G4Material* FindOrBuildMaterial(const G4Stri <<  76   G4Material* FindOrBuildMaterial (const G4String& name, 
 75                                                <<  77            G4bool isotopes=true,
 76   // Find or build a simple material via atomi <<  78            G4bool warning=true);
 77   inline G4Material* FindSimpleMaterial(G4int  <<  79               
 78   G4Material* FindOrBuildSimpleMaterial(G4int  << 
 79                                                << 
 80   // construct a G4Material from scratch by at     80   // construct a G4Material from scratch by atome count
 81   G4Material* ConstructNewMaterial(const G4Str <<  81   // 
 82     const std::vector<G4int>& nbAtoms, G4doubl <<  82   G4Material* ConstructNewMaterial (const G4String& name,
 83     G4double temp = NTP_Temperature, G4double  <<  83             const std::vector<G4String>& elm,
 84                                                <<  84             const std::vector<G4int>& nbAtoms,
                                                   >>  85             G4double dens, 
                                                   >>  86             G4bool isotopes=true,
                                                   >>  87             G4State   state    = kStateSolid,     
                                                   >>  88             G4double  temp     = STP_Temperature,  
                                                   >>  89             G4double  pressure = STP_Pressure); 
                                                   >>  90               
 85   // construct a G4Material from scratch by fr     91   // construct a G4Material from scratch by fraction mass
 86   G4Material* ConstructNewMaterial(const G4Str <<  92   //
 87     const std::vector<G4double>& weight, G4dou <<  93   G4Material* ConstructNewMaterial (const G4String& name,
 88     G4double temp = NTP_Temperature, G4double  <<  94             const std::vector<G4String>& elm,
                                                   >>  95             const std::vector<G4double>& weight,
                                                   >>  96             G4double dens, 
                                                   >>  97             G4bool isotopes=true,
                                                   >>  98             G4State   state    = kStateSolid,     
                                                   >>  99             G4double  temp     = STP_Temperature,  
                                                   >> 100             G4double  pressure = STP_Pressure); 
 89                                                   101 
 90   // construct a gas G4Material from scratch b << 
 91   G4Material* ConstructNewGasMaterial(         << 
 92     const G4String& name, const G4String& name << 
 93                                                   102 
 94   // Construct an ideal gas G4Material from sc << 103   // construct a gas G4Material from scratch by atome count
 95   G4Material* ConstructNewIdealGasMaterial(con << 104   // 
 96     const std::vector<G4int>& nbAtoms, G4doubl << 105   G4Material* ConstructNewGasMaterial(const G4String& name, 
 97     G4double pressure = CLHEP::STP_Pressure);  << 106               const G4String& nameNist,
                                                   >> 107               G4double temp, G4double pres, 
                                                   >> 108               G4bool isotopes=true);
 98                                                   109 
 99   // verbosity level defined by G4NistManager  << 
100   void SetVerbose(G4int val);                     110   void SetVerbose(G4int val);
                                                   >> 111   void ListMaterials(const G4String&);
                                                   >> 112   void ListNistSimpleMaterials();
                                                   >> 113   void ListNistCompoundMaterials();
                                                   >> 114   void ListHepMaterials();
101                                                   115 
102   // cout predefined materials:                << 
103   // "simple" - only pure materials in basic s << 
104   // "compound" - NIST compounds               << 
105   // "hep" - HEP materials and compounds       << 
106   // "biochemical" - bio-chemical materials    << 
107   // "all" - all                               << 
108   void ListMaterials(const G4String&) const;   << 
109                                                << 
110   // cout lists of predefined materials        << 
111   void ListNistSimpleMaterials() const;        << 
112   void ListNistCompoundMaterials() const;      << 
113   void ListHepMaterials() const;               << 
114   void ListSpaceMaterials() const;             << 
115   void ListBioChemicalMaterials() const;       << 
116                                                << 
117   // access to the list of names of Geant4 pre << 
118   const std::vector<G4String>& GetMaterialName    116   const std::vector<G4String>& GetMaterialNames() const;
119                                                   117 
120   // access to the NIST mean ionisation potent << 118 private:
121   inline G4double GetMeanIonisationEnergy(G4in << 
122   inline G4double GetNominalDensity(G4int inde << 
123                                                << 
124   G4bool operator==(const G4NistMaterialBuilde << 
125   G4bool operator!=(const G4NistMaterialBuilde << 
126   G4NistMaterialBuilder(const G4NistMaterialBu << 
127   const G4NistMaterialBuilder& operator=(const << 
128                                                   119 
129  private:                                      << 
130   void Initialise();                              120   void Initialise();
131   void NistSimpleMaterials();                     121   void NistSimpleMaterials();
132   void NistCompoundMaterials();                   122   void NistCompoundMaterials();
133   void NistCompoundMaterials2();               << 
134   void HepAndNuclearMaterials();                  123   void HepAndNuclearMaterials();
135   void SpaceMaterials();                       << 
136   void BioChemicalMaterials();                 << 
137                                                << 
138   // add parameters of material from NIST DB t << 
139   // density in g/cm3, mean ionisation potenti << 
140   //                                           << 
141   void AddMaterial(const G4String& nameMat, G4 << 
142     G4int ncomp = 1, G4State = kStateSolid, G4 << 
143                                                   124 
144   void AddGas(const G4String& nameMat, G4doubl << 125   void AddMaterial(const G4String& nameMat, G4double dens, G4int Z=0,
                                                   >> 126                          G4double pot=0.0, G4int ncomp=1,
                                                   >> 127                          G4State=kStateSolid,
                                                   >> 128                          G4double temp=STP_Temperature,
                                                   >> 129                          G4double pres=STP_Pressure);
                                                   >> 130 
                                                   >> 131   void AddChemicalFormula(const G4String& nameMat, const G4String& ch);
                                                   >> 132   void AddGas(const G4String& nameMat, G4double t=STP_Temperature,
                                                   >> 133               G4double p=STP_Pressure);
145                                                   134 
146   void AddElementByWeightFraction(G4int Z, G4d    135   void AddElementByWeightFraction(G4int Z, G4double);
147   void AddElementByAtomCount(G4int Z, G4int);  << 136   void AddElementByAtomCount     (G4int Z, G4int);
148                                                   137 
149   void AddElementByWeightFraction(const G4Stri    138   void AddElementByWeightFraction(const G4String& name, G4double);
150   void AddElementByAtomCount(const G4String& n << 139   void AddElementByAtomCount     (const G4String& name, G4int);
151                                                   140 
152   // build a G4Material from dataBase             141   // build a G4Material from dataBase
153   G4Material* BuildNistMaterial(const G4String << 142   G4Material* BuildMaterial(const G4String& name, G4bool isotopes);
154   G4Material* BuildMaterial(G4int idx);        << 143   G4Material* BuildMaterial(G4int idx, G4bool isotopes);
155                                                   144 
156   void DumpElm(G4int) const;                   << 145   void DumpElm(G4int);
157   void DumpMix(G4int) const;                   << 146   void DumpMix(G4int);
158                                                   147 
159  private:                                      << 148 private:
160   G4NistElementBuilder* elmBuilder;            << 
161                                                   149 
162   G4int verbose;                               << 150   G4NistElementBuilder*  elmBuilder;
163   G4int nMaterials{0};                         << 
164   G4int nComponents{0};                        << 
165   G4int nCurrent{0};                           << 
166   G4int nElementary;                           << 
167   G4int nNIST;                                 << 
168   G4int nHEP;                                  << 
169   G4int nSpace;                                << 
170                                                << 
171   std::vector<G4String> names;                 << 
172   std::vector<G4String> chFormulas;            << 
173                                                << 
174   std::vector<G4double> densities;             << 
175   std::vector<G4double> ionPotentials;         << 
176   std::vector<G4State> states;                 << 
177   std::vector<G4double> fractions;             << 
178   std::vector<G4bool> atomCount;               << 
179   std::vector<G4int> components;               << 
180   std::vector<G4int> indexes;                  << 
181   std::vector<G4int> elements;                 << 
182   std::vector<G4int> matIndex;                 << 
183   std::vector<G4bool> STP;                     << 
184                                                << 
185   std::vector<G4int> idxGas;                   << 
186   std::vector<G4double> gasTemperature;        << 
187   std::vector<G4double> gasPressure;           << 
188 };                                             << 
189                                                   151 
190 inline const std::vector<G4String>& G4NistMate << 152   G4int                  verbose;
191 {                                              << 153   G4int                  nMaterials;
192   return names;                                << 154   G4int                  nComponents;
193 }                                              << 155   G4int                  nCurrent;
                                                   >> 156   G4int                  nElementary;
                                                   >> 157   G4int                  nNIST;
194                                                   158 
195 inline G4double G4NistMaterialBuilder::GetMean << 159   std::vector<G4String>  names;
196 {                                              << 160   std::vector<G4String>  chFormulas;
197   return (index >= 0 && index < nMaterials) ?  << 
198 }                                              << 
199                                                   161 
200 inline G4double G4NistMaterialBuilder::GetNomi << 162   std::vector<G4double>  densities;
201 {                                              << 163   std::vector<G4double>  ionPotentials;
202   return (index >= 0 && index < nMaterials) ?  << 164   std::vector<G4State>   states;
203 }                                              << 165   std::vector<G4double>  fractions;
                                                   >> 166   std::vector<G4int>     components;
                                                   >> 167   std::vector<G4int>     indexes;
                                                   >> 168   std::vector<G4int>     elements;
204                                                   169 
205 inline G4Material* G4NistMaterialBuilder::Find << 170   std::vector<G4int>     matIndex;
206 {                                              << 171 
207   const G4MaterialTable* theMaterialTable = G4 << 172   std::vector<G4double>  temperatures;
208   G4Material* ptr = nullptr;                   << 173   std::vector<G4double>  presures;
209   for (auto& mat : *theMaterialTable) {        << 174 
210     if (name == mat->GetName()) {              << 175   G4bool                 first;
211       ptr = mat;                               << 
212       break;                                   << 
213     }                                          << 
214   }                                            << 
215   return ptr;                                  << 
216 }                                              << 
217                                                   176 
218 inline G4Material* G4NistMaterialBuilder::Find << 177 };
                                                   >> 178 
                                                   >> 179 inline const std::vector<G4String>& 
                                                   >> 180        G4NistMaterialBuilder::GetMaterialNames() const
219 {                                                 181 {
220   return (Z > 0 && Z < nElementary) ? FindMate << 182   return names;
221 }                                                 183 }
222                                                   184 
223 #endif                                            185 #endif
224                                                   186