Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/persistency/ascii/src/G4tgrMaterialFactory.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/G4tgrMaterialFactory.cc (Version 11.3.0) and /persistency/ascii/src/G4tgrMaterialFactory.cc (Version 10.6.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 //                                                 25 //
 26 // G4tgrMaterialFactory implementation         << 
 27 //                                                 26 //
 28 // Author: P.Arce, CIEMAT (November 2007)      <<  27 //
 29 // ------------------------------------------- <<  28 //
                                                   >>  29 // class G4tgrMaterialFactory
                                                   >>  30 
                                                   >>  31 // History:
                                                   >>  32 // - Created.                                 P.Arce, CIEMAT (November 2007)
                                                   >>  33 // -------------------------------------------------------------------------
 30                                                    34 
 31 #include "G4tgrMaterialFactory.hh"                 35 #include "G4tgrMaterialFactory.hh"
 32 #include "G4tgrUtils.hh"                           36 #include "G4tgrUtils.hh"
 33 #include "G4tgrElementSimple.hh"                   37 #include "G4tgrElementSimple.hh"
 34 #include "G4tgrElementFromIsotopes.hh"             38 #include "G4tgrElementFromIsotopes.hh"
 35 #include "G4tgrMaterialSimple.hh"                  39 #include "G4tgrMaterialSimple.hh"
 36 #include "G4tgrMaterialMixture.hh"                 40 #include "G4tgrMaterialMixture.hh"
 37 #include "G4tgrFileReader.hh"                      41 #include "G4tgrFileReader.hh"
 38 #include "G4tgrMessenger.hh"                       42 #include "G4tgrMessenger.hh"
 39                                                    43 
 40 G4ThreadLocal G4tgrMaterialFactory* G4tgrMater << 
 41                                                    44 
 42 // ------------------------------------------- <<  45 G4ThreadLocal G4tgrMaterialFactory* G4tgrMaterialFactory::theInstance = 0;
                                                   >>  46 
                                                   >>  47 
                                                   >>  48 //-------------------------------------------------------------
 43 G4tgrMaterialFactory::G4tgrMaterialFactory()       49 G4tgrMaterialFactory::G4tgrMaterialFactory()
 44 {                                                  50 {
 45 }                                                  51 }
 46                                                    52 
 47 // ------------------------------------------- <<  53 
                                                   >>  54 //-------------------------------------------------------------
 48 G4tgrMaterialFactory* G4tgrMaterialFactory::Ge     55 G4tgrMaterialFactory* G4tgrMaterialFactory::GetInstance()
 49 {                                                  56 {
 50   if(theInstance == nullptr)                   <<  57   if( !theInstance )
 51   {                                                58   {
 52     theInstance = new G4tgrMaterialFactory;        59     theInstance = new G4tgrMaterialFactory;
 53   }                                                60   }
 54   return theInstance;                              61   return theInstance;
 55 }                                                  62 }
 56                                                    63 
 57 // ------------------------------------------- <<  64 
                                                   >>  65 //-------------------------------------------------------------
 58 G4tgrMaterialFactory::~G4tgrMaterialFactory()      66 G4tgrMaterialFactory::~G4tgrMaterialFactory()
 59 {                                                  67 {
 60   for(auto isotcite = theG4tgrIsotopes.cbegin( <<  68   G4mstgrisot::iterator isotcite;
 61            isotcite != theG4tgrIsotopes.cend() <<  69   for( isotcite = theG4tgrIsotopes.begin();
                                                   >>  70        isotcite != theG4tgrIsotopes.end(); isotcite++)
 62   {                                                71   {
 63     delete(*isotcite).second;                  <<  72     delete (*isotcite).second;
 64   }                                                73   }
 65   theG4tgrIsotopes.clear();                        74   theG4tgrIsotopes.clear();
 66                                                    75 
 67   for(auto elemcite = theG4tgrElements.cbegin( <<  76   G4mstgrelem::iterator elemcite;
 68            elemcite != theG4tgrElements.cend() <<  77   for( elemcite = theG4tgrElements.begin();
                                                   >>  78        elemcite != theG4tgrElements.end(); elemcite++)
 69   {                                                79   {
 70     delete(*elemcite).second;                  <<  80     delete (*elemcite).second;
 71   }                                                81   }
 72   theG4tgrElements.clear();                        82   theG4tgrElements.clear();
 73                                                    83 
 74   for(auto matcite = theG4tgrMaterials.cbegin( <<  84   G4mstgrmate::iterator matcite;
 75            matcite != theG4tgrMaterials.cend() <<  85   for( matcite = theG4tgrMaterials.begin();
                                                   >>  86        matcite != theG4tgrMaterials.end(); matcite++)
 76   {                                                87   {
 77     delete(*matcite).second;                   <<  88     delete (*matcite).second;
 78   }                                                89   }
 79   theG4tgrMaterials.clear();                       90   theG4tgrMaterials.clear();
 80   delete theInstance;                              91   delete theInstance;
 81 }                                                  92 }
 82                                                    93 
 83 // ------------------------------------------- <<  94 
 84 G4tgrIsotope* G4tgrMaterialFactory::AddIsotope <<  95 //-------------------------------------------------------------
                                                   >>  96 G4tgrIsotope*
                                                   >>  97 G4tgrMaterialFactory::AddIsotope( const std::vector<G4String>& wl )
 85 {                                                  98 {
 86   //---------- Look if isotope exists              99   //---------- Look if isotope exists
 87   if(FindIsotope(G4tgrUtils::GetString(wl[1])) << 100   if( FindIsotope( G4tgrUtils::GetString(wl[1]) ) != 0 )
 88   {                                               101   {
 89     ErrorAlreadyExists("isotope", wl);         << 102     ErrorAlreadyExists("isotope", wl );
 90   }                                               103   }
 91                                                << 104   
 92   G4tgrIsotope* isot = new G4tgrIsotope(wl);   << 105   G4tgrIsotope* isot = new G4tgrIsotope( wl );
 93   theG4tgrIsotopes[isot->GetName()] = isot;       106   theG4tgrIsotopes[isot->GetName()] = isot;
 94                                                   107 
 95   return isot;                                    108   return isot;
 96 }                                                 109 }
 97                                                   110 
 98 // ------------------------------------------- << 111 //-------------------------------------------------------------
 99 G4tgrElementSimple*                               112 G4tgrElementSimple*
100 G4tgrMaterialFactory::AddElementSimple(const s << 113 G4tgrMaterialFactory::AddElementSimple( const std::vector<G4String>& wl )
101 {                                                 114 {
102   //---------- Look if element exists             115   //---------- Look if element exists
103   if(FindElement(G4tgrUtils::GetString(wl[1])) << 116   if( FindElement( G4tgrUtils::GetString(wl[1]) ) != 0 )
104   {                                               117   {
105     ErrorAlreadyExists("element", wl);         << 118     ErrorAlreadyExists("element", wl );
106   }                                               119   }
107                                                << 120   
108   G4tgrElementSimple* elem = new G4tgrElementS << 121   G4tgrElementSimple* elem = new G4tgrElementSimple( wl );
109   theG4tgrElements[elem->GetName()] = elem;       122   theG4tgrElements[elem->GetName()] = elem;
110                                                   123 
111   return elem;                                    124   return elem;
112 }                                                 125 }
113                                                   126 
114 // ------------------------------------------- << 127 
                                                   >> 128 //-------------------------------------------------------------
115 G4tgrElementFromIsotopes*                         129 G4tgrElementFromIsotopes*
116 G4tgrMaterialFactory::AddElementFromIsotopes(c << 130 G4tgrMaterialFactory::AddElementFromIsotopes( const std::vector<G4String>& wl )
117 {                                                 131 {
118   //---------- Look if element exists             132   //---------- Look if element exists
119   if(FindElement(G4tgrUtils::GetString(wl[1])) << 133   if( FindElement( G4tgrUtils::GetString(wl[1]) ) != 0 )
120   {                                               134   {
121     ErrorAlreadyExists("element", wl);         << 135     ErrorAlreadyExists("element", wl );
122   }                                               136   }
123                                                << 137   
124   G4tgrElementFromIsotopes* elem = new G4tgrEl << 138   G4tgrElementFromIsotopes* elem = new G4tgrElementFromIsotopes( wl );
125   theG4tgrElements[elem->GetName()] = elem;       139   theG4tgrElements[elem->GetName()] = elem;
126                                                   140 
127   return elem;                                    141   return elem;
128 }                                                 142 }
129                                                   143 
130 // ------------------------------------------- << 144 
                                                   >> 145 //-------------------------------------------------------------
131 G4tgrMaterialSimple*                              146 G4tgrMaterialSimple*
132 G4tgrMaterialFactory::AddMaterialSimple(const  << 147 G4tgrMaterialFactory::AddMaterialSimple( const std::vector<G4String>& wl )
133 {                                                 148 {
134 #ifdef G4VERBOSE                                  149 #ifdef G4VERBOSE
135   if(G4tgrMessenger::GetVerboseLevel() >= 2)   << 150   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
136   {                                               151   {
137     G4cout << " G4tgrMaterialFactory::AddMater    152     G4cout << " G4tgrMaterialFactory::AddMaterialSimple" << wl[1] << G4endl;
138   }                                               153   }
139 #endif                                            154 #endif
140                                                   155 
141   //---------- Look if material exists            156   //---------- Look if material exists
142   if(FindMaterial(G4tgrUtils::GetString(wl[1]) << 157   if( FindMaterial( G4tgrUtils::GetString(wl[1]) ) != 0 )
143   {                                               158   {
144     ErrorAlreadyExists("material simple", wl); << 159     ErrorAlreadyExists("material simple", wl );
145   }                                               160   }
146                                                   161 
147   G4tgrMaterialSimple* mate = new G4tgrMateria << 162   G4tgrMaterialSimple* mate = new G4tgrMaterialSimple("MaterialSimple", wl );
148                                                   163 
149   //---------- register this material             164   //---------- register this material
150   theG4tgrMaterials[mate->GetName()] = mate;   << 165   theG4tgrMaterials[ mate->GetName() ] = mate;
151                                                << 166   
152   return mate;                                    167   return mate;
153 }                                                 168 }
154                                                   169 
155 // ------------------------------------------- << 170 
                                                   >> 171 //-------------------------------------------------------------
156 G4tgrMaterialMixture*                             172 G4tgrMaterialMixture*
157 G4tgrMaterialFactory::AddMaterialMixture(const << 173 G4tgrMaterialFactory::AddMaterialMixture( const std::vector<G4String>& wl,
158                                          const << 174                                           const G4String& mixtType )
159 {                                                 175 {
160 #ifdef G4VERBOSE                                  176 #ifdef G4VERBOSE
161   if(G4tgrMessenger::GetVerboseLevel() >= 2)   << 177   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
162   {                                               178   {
163     G4cout << " G4tgrMaterialFactory::AddMater    179     G4cout << " G4tgrMaterialFactory::AddMaterialMixture " << wl[1] << G4endl;
164   }                                               180   }
165 #endif                                            181 #endif
166                                                   182 
167   //---------- Look if material already exists    183   //---------- Look if material already exists
168   if(FindMaterial(G4tgrUtils::GetString(wl[1]) << 184   if( FindMaterial( G4tgrUtils::GetString(wl[1]) ) != 0 )
169   {                                               185   {
170     ErrorAlreadyExists("material mixture", wl) << 186     ErrorAlreadyExists("material mixture", wl );
171   }                                               187   }
172                                                   188 
173   G4tgrMaterialMixture* mate;                  << 189   G4tgrMaterialMixture* mate; 
174   mate = new G4tgrMaterialMixture(mixtType, wl << 190   mate = new G4tgrMaterialMixture( mixtType, wl );
175                                                << 191   
176   //---------- register this material             192   //---------- register this material
177   theG4tgrMaterials[mate->GetName()] = mate;   << 193   theG4tgrMaterials[ mate->GetName() ] = mate;
178                                                << 194   
179   return mate;                                    195   return mate;
180 }                                                 196 }
181                                                   197 
182 // ------------------------------------------- << 198 
183 G4tgrIsotope* G4tgrMaterialFactory::FindIsotop << 199 //-------------------------------------------------------------
                                                   >> 200 G4tgrIsotope* G4tgrMaterialFactory::FindIsotope(const G4String & name) const 
184 {                                                 201 {
185 #ifdef G4VERBOSE                                  202 #ifdef G4VERBOSE
186   if(G4tgrMessenger::GetVerboseLevel() >= 3)   << 203   if( G4tgrMessenger::GetVerboseLevel() >= 3 )
187   {                                               204   {
188     G4cout << " G4tgrMaterialFactory::FindIsot << 205      G4cout << " G4tgrMaterialFactory::FindIsotope() - " << name << G4endl;
189   }                                               206   }
190 #endif                                            207 #endif
191                                                   208 
192   G4mstgrisot::const_iterator cite;               209   G4mstgrisot::const_iterator cite;
193   cite = theG4tgrIsotopes.find(name);          << 210   cite = theG4tgrIsotopes.find( name ); 
194   if(cite == theG4tgrIsotopes.cend())          << 211   if( cite == theG4tgrIsotopes.end() )
195   {                                               212   {
196     return nullptr;                            << 213     return 0;
197   }                                               214   }
198   else                                            215   else
199   {                                               216   {
200 #ifdef G4VERBOSE                                  217 #ifdef G4VERBOSE
201     if(G4tgrMessenger::GetVerboseLevel() >= 3) << 218     if( G4tgrMessenger::GetVerboseLevel() >= 3 )
202     {                                             219     {
203       G4cout << " G4tgrIsotope found: " << ((* << 220       G4cout << " G4tgrIsotope found: "
204              << G4endl;                        << 221              << ( (*cite).second )->GetName() << G4endl;
205     }                                             222     }
206 #endif                                            223 #endif
207     return (*cite).second;                        224     return (*cite).second;
208   }                                               225   }
209 }                                                 226 }
210                                                   227 
211 // ------------------------------------------- << 228 
212 G4tgrElement* G4tgrMaterialFactory::FindElemen << 229 //-------------------------------------------------------------
                                                   >> 230 G4tgrElement* G4tgrMaterialFactory::FindElement(const G4String & name) const 
213 {                                                 231 {
214 #ifdef G4VERBOSE                                  232 #ifdef G4VERBOSE
215   if(G4tgrMessenger::GetVerboseLevel() >= 3)   << 233   if( G4tgrMessenger::GetVerboseLevel() >= 3 )
216   {                                               234   {
217     G4cout << " G4tgrMaterialFactory::FindElem    235     G4cout << " G4tgrMaterialFactory::FindElement() - " << name << G4endl;
218   }                                               236   }
219 #endif                                            237 #endif
220   G4mstgrelem::const_iterator cite;               238   G4mstgrelem::const_iterator cite;
221   cite = theG4tgrElements.find(name);          << 239   cite = theG4tgrElements.find( name ); 
222   if(cite == theG4tgrElements.cend())          << 240   if( cite == theG4tgrElements.end() )
223   {                                               241   {
224     return nullptr;                            << 242     return 0;
225   }                                               243   }
226   else                                            244   else
227   {                                               245   {
228 #ifdef G4VERBOSE                                  246 #ifdef G4VERBOSE
229     if(G4tgrMessenger::GetVerboseLevel() >= 3) << 247     if( G4tgrMessenger::GetVerboseLevel() >= 3 )
230     {                                             248     {
231       DumpElementList();                          249       DumpElementList();
232       G4cout << " G4tgrElement found: " << ((* << 250       G4cout << " G4tgrElement found: "
233              << G4endl;                        << 251              << ( (*cite).second )->GetName() << G4endl;
234     }                                             252     }
235 #endif                                            253 #endif
236     return (*cite).second;                        254     return (*cite).second;
237   }                                               255   }
238 }                                                 256 }
239                                                   257 
240 // ------------------------------------------- << 258 
241 G4tgrMaterial* G4tgrMaterialFactory::FindMater << 259 //-------------------------------------------------------------
                                                   >> 260 G4tgrMaterial* G4tgrMaterialFactory::FindMaterial(const G4String & name) const 
242 {                                                 261 {
243 #ifdef G4VERBOSE                                  262 #ifdef G4VERBOSE
244   if(G4tgrMessenger::GetVerboseLevel() >= 3)   << 263   if( G4tgrMessenger::GetVerboseLevel() >= 3 )
245   {                                               264   {
246     G4cout << " G4tgrMaterialFactory::FindMate    265     G4cout << " G4tgrMaterialFactory::FindMaterial() - " << name << G4endl;
247   }                                               266   }
248 #endif                                            267 #endif
249   G4mstgrmate::const_iterator cite;               268   G4mstgrmate::const_iterator cite;
250   cite = theG4tgrMaterials.find(name);         << 269   cite = theG4tgrMaterials.find( name );
251   if(cite == theG4tgrMaterials.cend())         << 270   if( cite == theG4tgrMaterials.end() )
252   {                                               271   {
253     return nullptr;                            << 272     return 0;
254   }                                               273   }
255   else                                            274   else
256   {                                               275   {
257     return (*cite).second;                        276     return (*cite).second;
258   }                                               277   }
259 }                                                 278 }
260                                                   279 
261 // ------------------------------------------- << 280 
                                                   >> 281 //-------------------------------------------------------------
262 void G4tgrMaterialFactory::DumpIsotopeList() c    282 void G4tgrMaterialFactory::DumpIsotopeList() const
263 {                                                 283 {
264   G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrIs    284   G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrIsotope's List " << G4endl;
265   for(auto cite = theG4tgrIsotopes.cbegin();   << 285   G4mstgrisot::const_iterator cite;
266            cite != theG4tgrIsotopes.cend(); ++ << 286   for(cite = theG4tgrIsotopes.begin(); cite != theG4tgrIsotopes.end(); cite++)
267   {                                               287   {
268     G4cout << " ISOT: " << (*cite).second->Get    288     G4cout << " ISOT: " << (*cite).second->GetName() << G4endl;
269   }                                               289   }
270 }                                                 290 }
271                                                   291 
272 // ------------------------------------------- << 292 
273 void G4tgrMaterialFactory::DumpElementList() c << 293 //-------------------------------------------------------------
                                                   >> 294 void G4tgrMaterialFactory::DumpElementList() const 
274 {                                                 295 {
275   G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrEl    296   G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrElement's List " << G4endl;
276   for(auto cite = theG4tgrElements.cbegin();   << 297   G4mstgrelem::const_iterator cite;
277            cite != theG4tgrElements.cend(); ++ << 298   for(cite = theG4tgrElements.begin(); cite != theG4tgrElements.end(); cite++)
278   {                                               299   {
279     G4cout << " ELEM: " << (*cite).second->Get    300     G4cout << " ELEM: " << (*cite).second->GetName() << G4endl;
280   }                                               301   }
281 }                                                 302 }
282                                                   303 
283 // ------------------------------------------- << 304 
                                                   >> 305 //-------------------------------------------------------------
284 void G4tgrMaterialFactory::DumpMaterialList()     306 void G4tgrMaterialFactory::DumpMaterialList() const
285 {                                                 307 {
286   G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrMa    308   G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrMaterial's List " << G4endl;
287   for(auto cite = theG4tgrMaterials.cbegin();  << 309   G4mstgrmate::const_iterator cite;
288            cite != theG4tgrMaterials.cend(); + << 310   for(cite = theG4tgrMaterials.begin(); cite != theG4tgrMaterials.end(); cite++)
289   {                                               311   {
290     G4tgrMaterial* mate = (*cite).second;         312     G4tgrMaterial* mate = (*cite).second;
291     G4cout << " MATE: " << mate->GetName() <<  << 313     G4cout << " MATE: " << mate->GetName() << " Type: " << mate->GetType() 
292            << " NoComponents= " << mate->GetNu    314            << " NoComponents= " << mate->GetNumberOfComponents() << G4endl;
293   }                                               315   }
294 }                                                 316 }
                                                   >> 317  
295                                                   318 
296 // ------------------------------------------- << 319 //-------------------------------------------------------------
297 void G4tgrMaterialFactory::ErrorAlreadyExists( << 320 void G4tgrMaterialFactory::
298                                                << 321 ErrorAlreadyExists(const G4String& object,
299                                                << 322                    const std::vector<G4String>& wl, const G4bool bNoRepeating )
300 {                                                 323 {
301   G4String msg = object + G4String(" repeated"    324   G4String msg = object + G4String(" repeated");
302   if(bNoRepeating)                             << 325   if( bNoRepeating )
303   {                                               326   {
304     G4tgrUtils::DumpVS(wl, (G4String("!!!! EXI << 327     G4tgrUtils::DumpVS( wl, (G4String("!!!! EXITING: ") + msg).c_str() );
305     G4Exception("G4tgrMaterialFactory", "Fatal << 328     G4Exception("G4tgrMaterialFactory", "FatalError",
306                 "Aborting...");                << 329                 FatalException, "Aborting...");
307   }                                               330   }
308   else                                            331   else
309   {                                               332   {
310 #ifdef G4VERBOSE                                  333 #ifdef G4VERBOSE
311     if(G4tgrMessenger::GetVerboseLevel() >= 1) << 334     if( G4tgrMessenger::GetVerboseLevel() >= 1 )
312     {                                             335     {
313       G4tgrUtils::DumpVS(wl, (G4String("!! WAR << 336       G4tgrUtils::DumpVS( wl, (G4String("!! WARNING: ") + msg).c_str() ); 
314     }                                             337     }
315 #endif                                            338 #endif
316   }                                               339   }
317 }                                                 340 }
318                                                   341