Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/persistency/ascii/src/G4tgbMaterialMgr.cc

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 /persistency/ascii/src/G4tgbMaterialMgr.cc (Version 11.3.0) and /persistency/ascii/src/G4tgbMaterialMgr.cc (Version 10.0.p1)


  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 // G4tgbMaterialMgr implementation             << 
 27 //                                                 26 //
 28 // Author: P.Arce, CIEMAT (November 2007)      <<  27 // $Id: G4tgbMaterialMgr.cc 66872 2013-01-15 01:25:57Z japost $
 29 // ------------------------------------------- <<  28 //
                                                   >>  29 //
                                                   >>  30 // class G4tgbMaterialMgr
                                                   >>  31 
                                                   >>  32 // History:
                                                   >>  33 // - Created.                                 P.Arce, CIEMAT (November 2007)
                                                   >>  34 // -------------------------------------------------------------------------
 30                                                    35 
 31 #include "G4tgbMaterialMgr.hh"                     36 #include "G4tgbMaterialMgr.hh"
 32 #include "G4tgbMaterialMixtureByWeight.hh"         37 #include "G4tgbMaterialMixtureByWeight.hh"
 33 #include "G4tgbMaterialMixtureByVolume.hh"         38 #include "G4tgbMaterialMixtureByVolume.hh"
 34 #include "G4tgbMaterialMixtureByNoAtoms.hh"        39 #include "G4tgbMaterialMixtureByNoAtoms.hh"
 35 #include "G4tgbMaterialSimple.hh"                  40 #include "G4tgbMaterialSimple.hh"
 36                                                    41 
 37 #include "G4tgrMaterialFactory.hh"                 42 #include "G4tgrMaterialFactory.hh"
 38 #include "G4tgrMaterialSimple.hh"                  43 #include "G4tgrMaterialSimple.hh"
 39 #include "G4tgrMaterialMixture.hh"                 44 #include "G4tgrMaterialMixture.hh"
 40 #include "G4tgrUtils.hh"                           45 #include "G4tgrUtils.hh"
 41 #include "G4tgrMessenger.hh"                       46 #include "G4tgrMessenger.hh"
 42 #include "G4NistManager.hh"                        47 #include "G4NistManager.hh"
 43                                                    48 
 44 G4ThreadLocal G4tgbMaterialMgr* G4tgbMaterialM << 
 45                                                    49 
 46 // ------------------------------------------- <<  50 G4ThreadLocal G4tgbMaterialMgr* G4tgbMaterialMgr::theInstance = 0;
                                                   >>  51 
                                                   >>  52 
                                                   >>  53 // -------------------------------------------------------------------------
 47 G4tgbMaterialMgr::G4tgbMaterialMgr()               54 G4tgbMaterialMgr::G4tgbMaterialMgr()
 48 {                                                  55 {
 49 }                                                  56 }
 50                                                    57 
 51 // ------------------------------------------- <<  58 
                                                   >>  59 // -------------------------------------------------------------------------
 52 G4tgbMaterialMgr* G4tgbMaterialMgr::GetInstanc     60 G4tgbMaterialMgr* G4tgbMaterialMgr::GetInstance()
 53 {                                                  61 {
 54   if(theInstance == nullptr)                   <<  62   if( !theInstance )
 55   {                                                63   {
 56     theInstance = new G4tgbMaterialMgr;            64     theInstance = new G4tgbMaterialMgr;
 57     theInstance->CopyIsotopes();                   65     theInstance->CopyIsotopes();
 58     theInstance->CopyElements();                   66     theInstance->CopyElements();
 59     theInstance->CopyMaterials();                  67     theInstance->CopyMaterials();
 60   }                                                68   }
 61   return theInstance;                              69   return theInstance;
 62 }                                                  70 }
 63                                                    71 
 64 // ------------------------------------------- <<  72 
                                                   >>  73 // -------------------------------------------------------------------------
 65 G4tgbMaterialMgr::~G4tgbMaterialMgr()              74 G4tgbMaterialMgr::~G4tgbMaterialMgr()
 66 {                                                  75 {
 67   for(auto isotcite = theG4tgbIsotopes.cbegin( <<  76   G4mstgbisot::const_iterator isotcite;
 68            isotcite != theG4tgbIsotopes.cend() <<  77   for( isotcite = theG4tgbIsotopes.begin();
                                                   >>  78        isotcite != theG4tgbIsotopes.end(); isotcite++)
 69   {                                                79   {
 70     delete(*isotcite).second;                  <<  80     delete (*isotcite).second;
 71   }                                                81   }
 72   theG4tgbIsotopes.clear();                        82   theG4tgbIsotopes.clear();
 73                                                    83 
 74   for(auto elemcite = theG4tgbElements.cbegin( <<  84   G4mstgbelem::const_iterator elemcite;
 75            elemcite != theG4tgbElements.cend() <<  85   for( elemcite = theG4tgbElements.begin();
                                                   >>  86        elemcite != theG4tgbElements.end(); elemcite++)
 76   {                                                87   {
 77     delete(*elemcite).second;                  <<  88     delete (*elemcite).second;
 78   }                                                89   }
 79   theG4tgbElements.clear();                        90   theG4tgbElements.clear();
 80                                                    91 
 81   for(auto matcite = theG4tgbMaterials.cbegin( <<  92   G4mstgbmate::const_iterator matcite;
 82            matcite != theG4tgbMaterials.cend() <<  93   for( matcite = theG4tgbMaterials.begin();
                                                   >>  94        matcite != theG4tgbMaterials.end(); matcite++)
 83   {                                                95   {
 84     delete(*matcite).second;                   <<  96     delete (*matcite).second;
 85   }                                                97   }
 86   theG4tgbMaterials.clear();                       98   theG4tgbMaterials.clear();
 87                                                    99 
 88   delete theInstance;                             100   delete theInstance;
 89 }                                                 101 }
 90                                                   102 
 91 // ------------------------------------------- << 103 
                                                   >> 104 // -------------------------------------------------------------------------
 92 void G4tgbMaterialMgr::CopyIsotopes()             105 void G4tgbMaterialMgr::CopyIsotopes()
 93 {                                                 106 {
 94   const G4mstgrisot tgrIsots =                 << 107   const G4mstgrisot tgrIsots
 95     G4tgrMaterialFactory::GetInstance()->GetIs << 108         = G4tgrMaterialFactory::GetInstance()->GetIsotopeList();
 96   for(auto cite = tgrIsots.cbegin(); cite != t << 109   G4mstgrisot::const_iterator cite;
                                                   >> 110   for( cite = tgrIsots.begin(); cite != tgrIsots.end(); cite++ )
 97   {                                               111   {
 98     G4tgrIsotope* tgr                = (*cite) << 112     G4tgrIsotope* tgr = (*cite).second;
 99     G4tgbIsotope* tgb                = new G4t << 113     G4tgbIsotope* tgb = new G4tgbIsotope( tgr );
100     theG4tgbIsotopes[tgb->GetName()] = tgb;       114     theG4tgbIsotopes[tgb->GetName()] = tgb;
101   }                                               115   }
102 }                                                 116 }
103                                                   117 
104 // ------------------------------------------- << 118 
                                                   >> 119 // -------------------------------------------------------------------------
105 void G4tgbMaterialMgr::CopyElements()             120 void G4tgbMaterialMgr::CopyElements()
106 {                                                 121 {
107   const G4mstgrelem tgrElems =                 << 122   const G4mstgrelem tgrElems
108     G4tgrMaterialFactory::GetInstance()->GetEl << 123         = G4tgrMaterialFactory::GetInstance()->GetElementList();
109   for(auto cite = tgrElems.cbegin(); cite != t << 124   G4mstgrelem::const_iterator cite;
                                                   >> 125   for( cite = tgrElems.begin(); cite != tgrElems.end(); cite++ )
110   {                                               126   {
111     G4tgrElement* tgr                = (*cite) << 127     G4tgrElement* tgr = (*cite).second;
112     G4tgbElement* tgb                = new G4t << 128     G4tgbElement* tgb = new G4tgbElement( tgr );
113     theG4tgbElements[tgb->GetName()] = tgb;       129     theG4tgbElements[tgb->GetName()] = tgb;
114   }                                               130   }
115 }                                                 131 }
116                                                   132 
117 // ------------------------------------------- << 133 
                                                   >> 134 // -------------------------------------------------------------------------
118 void G4tgbMaterialMgr::CopyMaterials()            135 void G4tgbMaterialMgr::CopyMaterials()
119 {                                                 136 {
120   const G4mstgrmate tgrMates =                 << 137   const G4mstgrmate tgrMates
121     G4tgrMaterialFactory::GetInstance()->GetMa << 138         = G4tgrMaterialFactory::GetInstance()->GetMaterialList();
122   for(auto cite = tgrMates.cbegin(); cite != t << 139   G4mstgrmate::const_iterator cite;
                                                   >> 140   for( cite = tgrMates.begin(); cite != tgrMates.end(); cite++ )
123   {                                               141   {
124     G4tgrMaterial* tgr = (*cite).second;          142     G4tgrMaterial* tgr = (*cite).second;
125     G4tgbMaterial* tgb = nullptr;              << 143     G4tgbMaterial* tgb = 0;
126     if(tgr->GetType() == "MaterialSimple")     << 144     if( tgr->GetType() == "MaterialSimple" ) {
127     {                                          << 145       tgb = new G4tgbMaterialSimple( tgr );
128       tgb = new G4tgbMaterialSimple(tgr);      << 146     } else if( tgr->GetType() == "MaterialMixtureByWeight" ) {
129     }                                          << 147       tgb = new G4tgbMaterialMixtureByWeight( tgr );
130     else if(tgr->GetType() == "MaterialMixture << 148     } else if( tgr->GetType() == "MaterialMixtureByNoAtoms" ) {
131     {                                          << 149       tgb = new G4tgbMaterialMixtureByNoAtoms( tgr );
132       tgb = new G4tgbMaterialMixtureByWeight(t << 150     } else if( tgr->GetType() == "MaterialMixtureByVolume" ) {
133     }                                          << 151       tgb = new G4tgbMaterialMixtureByVolume( tgr );
134     else if(tgr->GetType() == "MaterialMixture << 152     } else {
135     {                                          << 
136       tgb = new G4tgbMaterialMixtureByNoAtoms( << 
137     }                                          << 
138     else if(tgr->GetType() == "MaterialMixture << 
139     {                                          << 
140       tgb = new G4tgbMaterialMixtureByVolume(t << 
141     }                                          << 
142     else                                       << 
143     {                                          << 
144       return;                                     153       return;
145     }                                             154     }
146     theG4tgbMaterials[tgb->GetName()] = tgb;      155     theG4tgbMaterials[tgb->GetName()] = tgb;
147   }                                               156   }
148 }                                                 157 }
149                                                   158 
150 // ------------------------------------------- << 159 
151 G4Isotope* G4tgbMaterialMgr::FindOrBuildG4Isot << 160 // -------------------------------------------------------------------------
                                                   >> 161 G4Isotope* G4tgbMaterialMgr::FindOrBuildG4Isotope(const G4String & name) 
152 {                                                 162 {
153   G4Isotope* g4isot = FindBuiltG4Isotope(name) << 163   G4Isotope* g4isot = FindBuiltG4Isotope( name );
154   if(g4isot == nullptr)                        << 164   if( g4isot == 0 )
155   {                                               165   {
156     G4tgbIsotope* tgbisot = FindG4tgbIsotope(n << 166     G4tgbIsotope* tgbisot = FindG4tgbIsotope( name );
157     // FindG4tgbIsotope never returns nullptr, << 167     // FindG4tgbIsotope never returns 0, otherwise if not found, crashes
158     g4isot = tgbisot->BuildG4Isotope();           168     g4isot = tgbisot->BuildG4Isotope();
159     // Register it                                169     // Register it
160     G4String isotname       = g4isot->GetName( << 170     G4String isotname = g4isot->GetName();
161     theG4Isotopes[isotname] = g4isot;             171     theG4Isotopes[isotname] = g4isot;
162   }                                               172   }
163   else                                            173   else
164   {                                            << 174   { 
165 #ifdef G4VERBOSE                                  175 #ifdef G4VERBOSE
166     if(G4tgrMessenger::GetVerboseLevel() >= 1) << 176     if( G4tgrMessenger::GetVerboseLevel() >= 1 )
167     {                                             177     {
168       G4cout << " G4tgbMaterialMgr::FindOrBuil    178       G4cout << " G4tgbMaterialMgr::FindOrBuildG4Isotope() -"
169              << " G4Isotope already built: " <    179              << " G4Isotope already built: " << g4isot->GetName() << G4endl;
170     }                                             180     }
171 #endif                                            181 #endif
172   }                                               182   }
173                                                   183 
174 #ifdef G4VERBOSE                                  184 #ifdef G4VERBOSE
175   if(G4tgrMessenger::GetVerboseLevel() >= 2)   << 185   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
176   {                                               186   {
177     G4cout << " G4tgbMaterialMgr::FindOrBuildG << 187     G4cout << " G4tgbMaterialMgr::FindOrBuildG4Isotope() - Isotope: "
178            << G4endl;                          << 188            << name << G4endl;
179   }                                               189   }
180 #endif                                            190 #endif
181   return g4isot;                                  191   return g4isot;
182 }                                              << 192 } 
183                                                   193 
184 // ------------------------------------------- << 
185 G4Isotope* G4tgbMaterialMgr::FindBuiltG4Isotop << 
186 {                                              << 
187   G4Isotope* g4isot = nullptr;                 << 
188                                                   194 
189   G4msg4isot::const_iterator cite = theG4Isoto << 195 // -------------------------------------------------------------------------
190   if(cite != theG4Isotopes.cend())             << 196 G4Isotope* G4tgbMaterialMgr::FindBuiltG4Isotope(const G4String & name) const 
                                                   >> 197 {
                                                   >> 198   G4Isotope* g4isot = 0;
                                                   >> 199  
                                                   >> 200   G4msg4isot::const_iterator cite = theG4Isotopes.find( name );
                                                   >> 201   if( cite != theG4Isotopes.end() )
191   {                                               202   {
192     g4isot = (*cite).second;                      203     g4isot = (*cite).second;
193 #ifdef G4VERBOSE                                  204 #ifdef G4VERBOSE
194     if(G4tgrMessenger::GetVerboseLevel() >= 2) << 205     if( G4tgrMessenger::GetVerboseLevel() >= 2 )
195     {                                          << 206       {
196       G4cout << " G4tgbMaterialMgr::FindBuiltG << 207         G4cout << " G4tgbMaterialMgr::FindBuiltG4Isotope() - Isotope: "
197              << " = " << g4isot << G4endl;     << 208                << name << " = " << g4isot << G4endl;
198     }                                          << 209       }
199 #endif                                            210 #endif
200   }                                            << 211 
                                                   >> 212   } 
201                                                   213 
202   return g4isot;                                  214   return g4isot;
203 }                                                 215 }
204                                                   216 
205 // ------------------------------------------- << 217 
206 G4tgbIsotope* G4tgbMaterialMgr::FindG4tgbIsoto << 218 // -------------------------------------------------------------------------
207                                                << 219 G4tgbIsotope* G4tgbMaterialMgr::FindG4tgbIsotope(const G4String & name,
                                                   >> 220                                                        G4bool bMustExist ) const 
208 {                                                 221 {
209   G4tgbIsotope* isot = nullptr;                << 222   G4tgbIsotope* isot = 0;
210                                                   223 
211   G4mstgbisot::const_iterator cite = theG4tgbI << 224   G4mstgbisot::const_iterator cite = theG4tgbIsotopes.find( name ); 
212   if(cite != theG4tgbIsotopes.cend())          << 225   if( cite != theG4tgbIsotopes.end() )
213   {                                               226   {
214 #ifdef G4VERBOSE                                  227 #ifdef G4VERBOSE
215     if(G4tgrMessenger::GetVerboseLevel() >= 2) << 228     if( G4tgrMessenger::GetVerboseLevel() >= 2 )
216     {                                             229     {
217       G4cout << " G4tgbMaterialMgr::FindG4tgbI    230       G4cout << " G4tgbMaterialMgr::FindG4tgbIsotope() -"
218              << " G4tgbIsotope found: " << ((* << 231              << " G4tgbIsotope found: " << ( (*cite).second )->GetName()
219              << G4endl;                           232              << G4endl;
220     }                                             233     }
221 #endif                                            234 #endif
222     isot = (*cite).second;                        235     isot = (*cite).second;
223   }                                               236   }
224   if((isot == nullptr) && bMustExist)          << 237   if( (isot == 0) && bMustExist )
225   {                                               238   {
226     G4String ErrMessage = "Isotope " + name +     239     G4String ErrMessage = "Isotope " + name + " not found !";
227     G4Exception("G4tgbMaterialMgr::FindG4tgbIs << 240     G4Exception("G4tgbMaterialMgr::FindG4tgbIsotope()",
228                 FatalException, ErrMessage);   << 241                 "InvalidSetup", FatalException, ErrMessage);
229   }                                               242   }
230                                                   243 
231   return isot;                                    244   return isot;
232 }                                                 245 }
233                                                   246 
234 // ------------------------------------------- << 247 
235 G4Element* G4tgbMaterialMgr::FindOrBuildG4Elem << 248 // -------------------------------------------------------------------------
236                                                << 249 G4Element* G4tgbMaterialMgr::FindOrBuildG4Element(const G4String & name,
                                                   >> 250                                                   G4bool bMustExist ) 
237 {                                                 251 {
238   G4Element* g4elem = FindBuiltG4Element(name) << 252   G4Element* g4elem = FindBuiltG4Element( name );
239   if(g4elem == nullptr)                        << 253   if( g4elem == 0 )
240   {                                               254   {
241     G4tgbElement* tgbelem = FindG4tgbElement(n << 255     G4tgbElement* tgbelem = FindG4tgbElement( name, false );
242     if(tgbelem == nullptr)                     << 256     if( tgbelem == 0)
243     {                                             257     {
244       // If FindG4tgbElement returns nullptr,  << 258       // If FindG4tgbElement returns 0, look for a G4NISTElement
245       G4cout << "  G4NistManager::Instance()->    259       G4cout << "  G4NistManager::Instance()->FindOrBuildElement( " << G4endl;
246       g4elem = G4NistManager::Instance()->Find    260       g4elem = G4NistManager::Instance()->FindOrBuildElement(name);
247     }                                             261     }
248     else                                          262     else
249     {                                             263     {
250       if(tgbelem->GetType() == "ElementSimple" << 264       if( tgbelem->GetType() == "ElementSimple" )
251       {                                           265       {
252         g4elem = tgbelem->BuildG4ElementSimple    266         g4elem = tgbelem->BuildG4ElementSimple();
253       }                                           267       }
254       else if(tgbelem->GetType() == "ElementFr << 268       else if( tgbelem->GetType() == "ElementFromIsotopes" )
255       {                                           269       {
256         g4elem = tgbelem->BuildG4ElementFromIs    270         g4elem = tgbelem->BuildG4ElementFromIsotopes();
257       }                                           271       }
258       else                                        272       else
259       {                                           273       {
260         G4String ErrMessage =                  << 274         G4String ErrMessage = "Element type " + tgbelem->GetType()
261           "Element type " + tgbelem->GetType() << 275           + " does not exist !";
262         G4Exception("G4tgbMaterialMgr::GetG4El << 276         G4Exception("G4tgbMaterialMgr::GetG4Element()",
263                     FatalException, ErrMessage << 277                     "InvalidSetup", FatalException, ErrMessage);
264       }                                           278       }
265     }                                             279     }
266     // Register it                                280     // Register it
267     if((g4elem != nullptr))                    << 281     if( (g4elem != 0) )
268     {                                             282     {
269       theG4Elements[g4elem->GetName()] = g4ele    283       theG4Elements[g4elem->GetName()] = g4elem;
270 #ifdef G4VERBOSE                                  284 #ifdef G4VERBOSE
271       if(G4tgrMessenger::GetVerboseLevel() >=  << 285       if( G4tgrMessenger::GetVerboseLevel() >= 2 )
272       {                                        << 286         {
273         G4cout << " G4tgbMaterialMgr::FindOrBu << 287           G4cout << " G4tgbMaterialMgr::FindOrBuildG4Element() - Element: "
274                << name << G4endl;              << 288                  << name << G4endl;
275       }                                        << 289         }
276 #endif                                            290 #endif
277     }                                             291     }
278     else                                          292     else
279     {                                             293     {
280       if(bMustExist)                           << 294       if( bMustExist )
281       {                                           295       {
282         G4String ErrMessage = "Element " + nam    296         G4String ErrMessage = "Element " + name + " not found !";
283         G4Exception("G4tgbMaterialMgr::FindOrB << 297         G4Exception("G4tgbMaterialMgr::FindOrBuildG4Element()",
284                     FatalException, ErrMessage << 298                     "InvalidSetup", FatalException, ErrMessage);
285       }                                           299       }
286 #ifdef G4VERBOSE                                  300 #ifdef G4VERBOSE
287       if(G4tgrMessenger::GetVerboseLevel() >=  << 301       if( G4tgrMessenger::GetVerboseLevel() >= 2 )
288       {                                           302       {
289         G4cout << " G4tgbMaterialMgr::FindOrBu    303         G4cout << " G4tgbMaterialMgr::FindOrBuildG4Element() - Element: "
290                << name << " not found  " << G4    304                << name << " not found  " << G4endl;
291       }                                           305       }
292 #endif                                            306 #endif
293     }                                             307     }
294   }                                               308   }
295   else                                            309   else
296   {                                            << 310   { 
297 #ifdef G4VERBOSE                                  311 #ifdef G4VERBOSE
298     if(G4tgrMessenger::GetVerboseLevel() >= 1) << 312     if( G4tgrMessenger::GetVerboseLevel() >= 1 )
299     {                                             313     {
300       G4cout << " G4tgbMaterialMgr::GetG4Eleme    314       G4cout << " G4tgbMaterialMgr::GetG4Element() -"
301              << " G4Element already built: " < << 315              << " G4Element already built: " << g4elem->GetName() << G4endl; 
302     }                                             316     }
303 #endif                                            317 #endif
304   }                                               318   }
305                                                   319 
306   return g4elem;                                  320   return g4elem;
307 }                                              << 321 } 
308                                                   322 
309 // ------------------------------------------- << 
310 G4Element* G4tgbMaterialMgr::FindBuiltG4Elemen << 
311 {                                              << 
312   G4Element* g4elem = nullptr;                 << 
313                                                   323 
314   G4msg4elem::const_iterator cite = theG4Eleme << 324 // -------------------------------------------------------------------------
315   if(cite != theG4Elements.cend())             << 325 G4Element* G4tgbMaterialMgr::FindBuiltG4Element(const G4String & name) const 
                                                   >> 326 {
                                                   >> 327   G4Element* g4elem = 0;
                                                   >> 328  
                                                   >> 329   G4msg4elem::const_iterator cite = theG4Elements.find( name );
                                                   >> 330   if( cite != theG4Elements.end() )
316   {                                               331   {
317     g4elem = (*cite).second;                      332     g4elem = (*cite).second;
318 #ifdef G4VERBOSE                                  333 #ifdef G4VERBOSE
319     if(G4tgrMessenger::GetVerboseLevel() >= 2) << 334     if( G4tgrMessenger::GetVerboseLevel() >= 2 )
320     {                                             335     {
321       G4cout << " G4tgbMaterialMgr::FindBuiltG << 336       G4cout << " G4tgbMaterialMgr::FindBuiltG4Element() - Element: "
322              << " = " << g4elem << G4endl;     << 337              << name << " = " << g4elem << G4endl;
323     }                                             338     }
324 #endif                                            339 #endif
325   }                                            << 340   } 
326                                                   341 
327   return g4elem;                                  342   return g4elem;
328 }                                                 343 }
329                                                   344 
330 // ------------------------------------------- << 345 
331 G4tgbElement* G4tgbMaterialMgr::FindG4tgbEleme << 346 // -------------------------------------------------------------------------
332                                                << 347 G4tgbElement* G4tgbMaterialMgr::FindG4tgbElement(const G4String & name,
                                                   >> 348                                                        G4bool bMustExist ) const
333 {                                                 349 {
334   G4tgbElement* elem = nullptr;                << 350   G4tgbElement* elem = 0;
335                                                   351 
336   G4mstgbelem::const_iterator cite = theG4tgbE << 352   G4mstgbelem::const_iterator cite = theG4tgbElements.find( name ); 
337   if(cite != theG4tgbElements.cend())          << 353   if( cite != theG4tgbElements.end() )
338   {                                               354   {
339 #ifdef G4VERBOSE                                  355 #ifdef G4VERBOSE
340     if(G4tgrMessenger::GetVerboseLevel() >= 2) << 356     if( G4tgrMessenger::GetVerboseLevel() >= 2 )
341     {                                             357     {
342       G4cout << " G4tgbMaterialMgr::FindG4tgbE    358       G4cout << " G4tgbMaterialMgr::FindG4tgbElement() -"
343              << " G4tgbElement found: " << ((* << 359              << " G4tgbElement found: " << ( (*cite).second )->GetName()
344              << G4endl;                           360              << G4endl;
345     }                                             361     }
346 #endif                                            362 #endif
347     elem = (*cite).second;                        363     elem = (*cite).second;
348   }                                               364   }
349   if((elem == nullptr) && bMustExist)          << 365   if( (elem == 0) && bMustExist )
350   {                                               366   {
351     G4String ErrMessage = "Element " + name +     367     G4String ErrMessage = "Element " + name + "  not found !";
352     G4Exception("G4tgbMaterialMgr::FindG4tgbEl << 368     G4Exception("G4tgbMaterialMgr::FindG4tgbElement()",
353                 FatalException, ErrMessage);   << 369                 "InvalidSetup", FatalException, ErrMessage);
354   }                                               370   }
355                                                   371 
356   return elem;                                    372   return elem;
357 }                                                 373 }
358                                                   374 
359 // ------------------------------------------- << 375 
360 G4Material* G4tgbMaterialMgr::FindOrBuildG4Mat << 376 // -------------------------------------------------------------------------
361                                                << 377 G4Material* G4tgbMaterialMgr::FindOrBuildG4Material(const G4String & name,
                                                   >> 378                                                     G4bool bMustExist )  
362 {                                                 379 {
363   G4Material* g4mate = FindBuiltG4Material(nam << 380   G4Material* g4mate = FindBuiltG4Material( name );
364   if(g4mate == nullptr)                        << 381   if( g4mate == 0)
365   {                                               382   {
366     G4tgbMaterial* tgbmate = FindG4tgbMaterial << 383     G4tgbMaterial* tgbmate = FindG4tgbMaterial( name, false );
367                                                << 384    
368     if(tgbmate == nullptr)                     << 385     if( tgbmate == 0)
369     {                                             386     {
370       // if FindG4tgbMaterial() returns 0, loo    387       // if FindG4tgbMaterial() returns 0, look for a G4NISTMaterial
371       g4mate = G4NistManager::Instance()->Find    388       g4mate = G4NistManager::Instance()->FindOrBuildMaterial(name);
372     }                                             389     }
373     else                                          390     else
374     {                                             391     {
375       g4mate = tgbmate->BuildG4Material();        392       g4mate = tgbmate->BuildG4Material();
376                                                   393 
377       if(tgbmate->GetTgrMate()->GetIonisationM << 394       if( tgbmate->GetTgrMate()->GetIonisationMeanExcitationEnergy() != -1. )
378       {                                           395       {
379         g4mate->GetIonisation()->SetMeanExcita << 396         g4mate->GetIonisation()->SetMeanExcitationEnergy(tgbmate->
380           tgbmate->GetTgrMate()->GetIonisation << 397                 GetTgrMate()->GetIonisationMeanExcitationEnergy());
381       }                                           398       }
382     }                                             399     }
383                                                   400 
384     // Register it                                401     // Register it
385     if(g4mate != nullptr)                      << 402     if( g4mate != 0 )
386     {                                             403     {
387       theG4Materials[g4mate->GetName()] = g4ma    404       theG4Materials[g4mate->GetName()] = g4mate;
388 #ifdef G4VERBOSE                                  405 #ifdef G4VERBOSE
389       if(G4tgrMessenger::GetVerboseLevel() >=  << 406       if( G4tgrMessenger::GetVerboseLevel() >= 2 )
390       {                                           407       {
391         G4cout << " G4tgbMaterialMgr::FindOrBu    408         G4cout << " G4tgbMaterialMgr::FindOrBuildG4Material() - Material: "
392                << name << G4endl;                 409                << name << G4endl;
393       }                                           410       }
394 #endif                                            411 #endif
395     }                                             412     }
396     else                                          413     else
397     {                                             414     {
398       if(bMustExist)                           << 415       if( bMustExist )
399       {                                           416       {
400         G4String ErrMessage = "Material " + na    417         G4String ErrMessage = "Material " + name + "  not found !";
401         G4Exception("G4tgbMaterialMgr::FindOrB << 418         G4Exception("G4tgbMaterialMgr::FindOrBuildG4Material()",
402                     FatalException, ErrMessage << 419                     "InvalidSetup", FatalException, ErrMessage);
403       }                                        << 420       }  
404 #ifdef G4VERBOSE                                  421 #ifdef G4VERBOSE
405       if(G4tgrMessenger::GetVerboseLevel() >=  << 422       if( G4tgrMessenger::GetVerboseLevel() >= 2 )
406       {                                           423       {
407         G4cout << " G4tgbMaterialMgr::FindOrBu    424         G4cout << " G4tgbMaterialMgr::FindOrBuildG4Material() - Element: "
408                << name << " not found  " << G4    425                << name << " not found  " << G4endl;
409       }                                           426       }
410 #endif                                            427 #endif
411     }                                             428     }
412   }                                               429   }
413   else                                            430   else
414   {                                            << 431   { 
415 #ifdef G4VERBOSE                                  432 #ifdef G4VERBOSE
416     if(G4tgrMessenger::GetVerboseLevel() >= 1) << 433     if( G4tgrMessenger::GetVerboseLevel() >= 1 )
417     {                                             434     {
418       G4cout << " G4tgbMaterialMgr::FindOrBuil    435       G4cout << " G4tgbMaterialMgr::FindOrBuildG4Material() -"
419              << " G4Material already built: "     436              << " G4Material already built: " << g4mate->GetName() << G4endl;
420     }                                             437     }
421 #endif                                            438 #endif
422   }                                               439   }
423                                                   440 
424   return g4mate;                                  441   return g4mate;
425 }                                                 442 }
426                                                   443 
427 // ------------------------------------------- << 444 
428 G4Material* G4tgbMaterialMgr::FindBuiltG4Mater << 445 // -------------------------------------------------------------------------
                                                   >> 446 G4Material* G4tgbMaterialMgr::FindBuiltG4Material(const G4String & name) const 
429 {                                                 447 {
430   G4Material* g4mate = nullptr;                << 448   G4Material* g4mate = 0;
431   //---------- look for an existing G4Material    449   //---------- look for an existing G4Material
432   G4msg4mate::const_iterator cite = theG4Mater << 450   G4msg4mate::const_iterator cite = theG4Materials.find( name );
433   if(cite != theG4Materials.cend())            << 451   if( cite != theG4Materials.end() )
434   {                                               452   {
435     g4mate = (*cite).second;                      453     g4mate = (*cite).second;
436 #ifdef G4VERBOSE                                  454 #ifdef G4VERBOSE
437     if(G4tgrMessenger::GetVerboseLevel() >= 2) << 455     if( G4tgrMessenger::GetVerboseLevel() >= 2 )
438     {                                             456     {
439       G4cout << " G4tgbMaterialMgr::FindBuiltG << 457       G4cout << " G4tgbMaterialMgr::FindBuiltG4Material() - Material: "
440              << " = " << g4mate << G4endl;     << 458              << name << " = " << g4mate << G4endl;
441     }                                             459     }
442 #endif                                            460 #endif
443   }                                               461   }
444                                                   462 
445   return g4mate;                                  463   return g4mate;
446 }                                                 464 }
447                                                   465 
                                                   >> 466 
448 // -------------------------------------------    467 // -------------------------------------------------------------------------
449 G4tgbMaterial* G4tgbMaterialMgr::FindG4tgbMate << 468 G4tgbMaterial* G4tgbMaterialMgr::FindG4tgbMaterial(const G4String & name,
450                                                << 469                                                    G4bool bMustExist ) const 
451 {                                                 470 {
452   G4tgbMaterial* mate = nullptr;               << 471   G4tgbMaterial* mate = 0;
453   G4mstgbmate::const_iterator cite = theG4tgbM << 472   G4mstgbmate::const_iterator cite = theG4tgbMaterials.find( name );
454   if(cite != theG4tgbMaterials.cend())         << 473   if( cite != theG4tgbMaterials.end() )
455   {                                               474   {
456     mate = (*cite).second;                        475     mate = (*cite).second;
457 #ifdef G4VERBOSE                                  476 #ifdef G4VERBOSE
458     if(G4tgrMessenger::GetVerboseLevel() >= 2) << 477     if( G4tgrMessenger::GetVerboseLevel() >= 2 )
459     {                                             478     {
460       G4cout << " G4tgbMaterialMgr::FindG4tgbM    479       G4cout << " G4tgbMaterialMgr::FindG4tgbMaterial() -"
461              << " G4tgbMaterial found: " << (( << 480              << " G4tgbMaterial found: " << ( (*cite).second )->GetName()
462              << " type " << ((*cite).second)-> << 481              << " type " << ( (*cite).second )->GetName() << G4endl;
463     }                                             482     }
464 #endif                                            483 #endif
465   }                                               484   }
466                                                   485 
467   if((mate == nullptr) && bMustExist)          << 486   if( (mate == 0) && bMustExist )
468   {                                               487   {
469     G4String ErrMessage = "Material " + name +    488     G4String ErrMessage = "Material " + name + "  not found !";
470     G4Exception("G4tgbMaterialMgr::FindG4tgbMa << 489     G4Exception("G4tgbMaterialMgr::FindG4tgbMaterial()",
471                 FatalException, ErrMessage);   << 490                 "InvalidSetup", FatalException, ErrMessage);
472   }                                               491   }
473                                                   492 
474   return mate;                                    493   return mate;
475 }                                                 494 }
476                                                   495