| Geant4 Cross Reference |
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 // G4tgrVolumeMgr implementation <<
27 // 26 //
28 // Author: P.Arce, CIEMAT (November 2007) << 27 //
29 // ------------------------------------------- << 28 //
>> 29 // class G4tgrVolumeMgr
>> 30
>> 31 // History:
>> 32 // - Created. P.Arce, CIEMAT (November 2007)
>> 33 // -------------------------------------------------------------------------
30 34
31 #include "G4tgrVolumeMgr.hh" 35 #include "G4tgrVolumeMgr.hh"
32 #include "G4tgrUtils.hh" 36 #include "G4tgrUtils.hh"
33 #include "G4tgrMaterialFactory.hh" 37 #include "G4tgrMaterialFactory.hh"
34 #include "G4tgrRotationMatrixFactory.hh" 38 #include "G4tgrRotationMatrixFactory.hh"
35 #include "G4tgrFileReader.hh" 39 #include "G4tgrFileReader.hh"
36 #include "G4tgrMessenger.hh" 40 #include "G4tgrMessenger.hh"
37 #include "G4tgrSolid.hh" 41 #include "G4tgrSolid.hh"
38 #include "G4tgrSolidBoolean.hh" 42 #include "G4tgrSolidBoolean.hh"
39 #include "G4tgrSolidMultiUnion.hh" <<
40 #include "G4tgrSolidScaled.hh" <<
41 43
42 G4ThreadLocal G4tgrVolumeMgr* G4tgrVolumeMgr:: <<
43 44
44 // ------------------------------------------- << 45 G4ThreadLocal G4tgrVolumeMgr* G4tgrVolumeMgr::theInstance = 0;
>> 46
>> 47
>> 48 //-------------------------------------------------------------
45 G4tgrVolumeMgr::G4tgrVolumeMgr() 49 G4tgrVolumeMgr::G4tgrVolumeMgr()
46 { 50 {
47 } 51 }
48 52
49 // ------------------------------------------- << 53
>> 54 //-------------------------------------------------------------
50 G4tgrVolumeMgr::~G4tgrVolumeMgr() 55 G4tgrVolumeMgr::~G4tgrVolumeMgr()
51 { << 56 {
52 delete theInstance; 57 delete theInstance;
53 } 58 }
54 59
55 // ------------------------------------------- << 60
>> 61 //-------------------------------------------------------------
56 G4tgrVolumeMgr* G4tgrVolumeMgr::GetInstance() 62 G4tgrVolumeMgr* G4tgrVolumeMgr::GetInstance()
57 { 63 {
58 if(theInstance == nullptr) << 64 if( !theInstance )
59 { 65 {
60 theInstance = new G4tgrVolumeMgr; 66 theInstance = new G4tgrVolumeMgr;
61 } 67 }
62 return theInstance; 68 return theInstance;
63 } 69 }
64 70
65 // ------------------------------------------- << 71
66 G4tgrSolid* G4tgrVolumeMgr::CreateSolid(const << 72 //-------------------------------------------------------------------
67 G4bool << 73 G4tgrSolid*
>> 74 G4tgrVolumeMgr::CreateSolid( const std::vector<G4String>& wl, G4bool bVOLUtag )
68 { 75 {
69 G4tgrSolid* sol = FindSolid(wl[1]); << 76 G4tgrSolid* sol = FindSolid( wl[1] );
70 if(sol != nullptr) << 77 if( sol )
71 { 78 {
72 G4String ErrMessage = "Solid already exist 79 G4String ErrMessage = "Solid already exists... " + wl[1];
73 G4Exception("G4tgrVolumeMgr::CreateSolid() << 80 G4Exception("G4tgrVolumeMgr::CreateSolid()", "InvalidSetup",
74 ErrMessage); << 81 FatalException, ErrMessage);
75 } << 82 }
76 << 83
77 std::vector<G4String> wlc = wl; 84 std::vector<G4String> wlc = wl;
78 if(bVOLUtag) << 85 if( bVOLUtag ) { wlc.pop_back(); }
79 { <<
80 wlc.pop_back(); <<
81 } <<
82 86
83 G4String wl2 = wlc[2]; 87 G4String wl2 = wlc[2];
84 for(G4int ii = 0; ii < (G4int)wl2.length(); << 88 for( size_t ii = 0; ii < wl2.length(); ii++ )
85 { 89 {
86 wl2[ii] = (char)std::toupper(wl2[ii]); << 90 wl2[ii] = toupper( wl2[ii] );
87 } 91 }
88 if((wl2 == "UNION") || (wl2 == "SUBTRACTION" << 92 if( (wl2 == "UNION") || (wl2 == "SUBTRACTION") || (wl2 == "INTERSECTION") )
89 { 93 {
90 //---------- Boolean solid 94 //---------- Boolean solid
91 //---------- Create G4tgrSolidBoolean and 95 //---------- Create G4tgrSolidBoolean and fill the solid params
92 sol = new G4tgrSolidBoolean(wlc); << 96 sol = new G4tgrSolidBoolean( wlc );
93 } <<
94 else if(wl2 == "SCALED") <<
95 { <<
96 //---------- Create G4tgrSolidScaled and f <<
97 sol = new G4tgrSolidScaled(wlc); <<
98 } <<
99 else if(wl2 == "MULTIUNION") <<
100 { <<
101 //---------- Create G4tgrSolidMultiUnion a <<
102 sol = new G4tgrSolidMultiUnion(wlc); <<
103 } 97 }
104 else 98 else
105 { 99 {
106 //---------- Create G4tgrSolidSimple and f 100 //---------- Create G4tgrSolidSimple and fill the solid params
107 sol = new G4tgrSolid(wlc); << 101 sol = new G4tgrSolid( wlc );
108 } 102 }
109 103
110 return sol; 104 return sol;
111 } 105 }
112 106
113 // ------------------------------------------- << 107 //-------------------------------------------------------------------
114 void G4tgrVolumeMgr::RegisterMe(G4tgrSolid* so << 108 void G4tgrVolumeMgr::RegisterMe( G4tgrSolid* sol)
115 { 109 {
116 if(theG4tgrSolidMap.find(sol->GetName()) != << 110 if( theG4tgrSolidMap.find( sol->GetName() ) != theG4tgrSolidMap.end() )
117 { 111 {
118 G4String ErrMessage = << 112 G4String ErrMessage = "Cannot be two solids with the same name... "
119 "Cannot be two solids with the same name << 113 + sol->GetName();
120 G4Exception("G4tgrVolumeMgr::RegisterMe()" << 114 G4Exception("G4tgrVolumeMgr::RegisterMe()", "InvalidSetup",
121 ErrMessage); << 115 FatalException, ErrMessage);
122 } 116 }
123 theG4tgrSolidMap.insert(G4mapssol::value_typ << 117 theG4tgrSolidMap.insert(G4mapssol::value_type(sol->GetName(), sol) );
124 } 118 }
125 119
126 // ------------------------------------------- << 120
127 void G4tgrVolumeMgr::UnRegisterMe(G4tgrSolid* << 121 //-------------------------------------------------------------
>> 122 void G4tgrVolumeMgr::UnRegisterMe( G4tgrSolid* sol )
128 { 123 {
129 if(theG4tgrSolidMap.find(sol->GetName()) != << 124 if( theG4tgrSolidMap.find( sol->GetName() ) != theG4tgrSolidMap.end() )
130 { << 125 {
131 G4String ErrMessage = << 126 G4String ErrMessage = "Cannot unregister a solid that is not registered... "
132 "Cannot unregister a solid that is not r << 127 + sol->GetName();
133 G4Exception("G4tgrSolidMgr::unRegisterMe() << 128 G4Exception("G4tgrSolidMgr::unRegisterMe()", "InvalidSetup",
134 ErrMessage); << 129 FatalException, ErrMessage);
135 } 130 }
136 else 131 else
137 { 132 {
138 theG4tgrSolidMap.erase(theG4tgrSolidMap.fi << 133 theG4tgrSolidMap.erase( theG4tgrSolidMap.find( sol->GetName() ) );
139 } 134 }
140 } 135 }
141 136
142 // ------------------------------------------- << 137
143 void G4tgrVolumeMgr::RegisterMe(G4tgrVolume* v << 138 //-------------------------------------------------------------
>> 139 void G4tgrVolumeMgr::RegisterMe( G4tgrVolume* vol)
144 { 140 {
145 theG4tgrVolumeList.push_back(vol); << 141 theG4tgrVolumeList.push_back( vol );
146 if(theG4tgrVolumeMap.find(vol->GetName()) != << 142 if( theG4tgrVolumeMap.find( vol->GetName() ) != theG4tgrVolumeMap.end() )
147 { 143 {
148 G4String ErrMessage = << 144 G4String ErrMessage = "Cannot be two volumes with the same name... "
149 "Cannot be two volumes with the same nam << 145 + vol->GetName();
150 G4Exception("G4tgrVolumeMgr::RegisterMe()" << 146 G4Exception("G4tgrVolumeMgr::RegisterMe()", "InvalidSetup",
151 ErrMessage); << 147 FatalException, ErrMessage);
152 } 148 }
153 theG4tgrVolumeMap.insert(G4mapsvol::value_ty << 149 theG4tgrVolumeMap.insert(G4mapsvol::value_type(vol->GetName(), vol) );
154 } 150 }
155 151
156 // ------------------------------------------- << 152
157 void G4tgrVolumeMgr::UnRegisterMe(G4tgrVolume* << 153 //-------------------------------------------------------------
>> 154 void G4tgrVolumeMgr::UnRegisterMe( G4tgrVolume* vol )
158 { 155 {
159 std::vector<G4tgrVolume*>::const_iterator it << 156 std::vector<G4tgrVolume*>::iterator ite;
160 for(ite = theG4tgrVolumeList.cbegin(); << 157 for(ite = theG4tgrVolumeList.begin(); ite != theG4tgrVolumeList.end(); ite++)
161 ite != theG4tgrVolumeList.cend(); ++ite) <<
162 { 158 {
163 if((*ite) == vol) << 159 if((*ite) == vol ) { break; }
164 { <<
165 break; <<
166 } <<
167 } 160 }
168 if(ite == theG4tgrVolumeList.cend()) << 161 if( ite == theG4tgrVolumeList.end() )
169 { << 162 {
170 G4String ErrMessage = << 163 G4String ErrMessage = "Cannot unregister a volume not registered... "
171 "Cannot unregister a volume not register << 164 + vol->GetName();
172 G4Exception("G4tgrVolumeMgr::unRegisterMe( 165 G4Exception("G4tgrVolumeMgr::unRegisterMe()", "InvalidSetup",
173 FatalException, ErrMessage); 166 FatalException, ErrMessage);
174 } 167 }
175 else 168 else
176 { 169 {
177 theG4tgrVolumeList.erase(ite); << 170 theG4tgrVolumeList.erase( ite );
178 } 171 }
179 theG4tgrVolumeMap.erase(theG4tgrVolumeMap.fi << 172 theG4tgrVolumeMap.erase( theG4tgrVolumeMap.find( vol->GetName() ) );
180 } 173 }
181 174
182 // ------------------------------------------- << 175
183 void G4tgrVolumeMgr::RegisterParentChild(const << 176 //-------------------------------------------------------------
184 const << 177
185 { << 178 void G4tgrVolumeMgr::RegisterParentChild( const G4String& parentName,
186 theG4tgrVolumeTree.insert(G4mmapspl::value_t << 179 const G4tgrPlace* pl )
>> 180 {
>> 181 theG4tgrVolumeTree.insert(G4mmapspl::value_type(parentName, pl) );
187 } 182 }
188 183
189 // ------------------------------------------- <<
190 G4tgrSolid* G4tgrVolumeMgr::FindSolid(const G4 <<
191 { <<
192 G4tgrSolid* vol = nullptr; <<
193 184
194 G4mapssol::const_iterator svite = theG4tgrSo << 185 //-------------------------------------------------------------
195 if(svite == theG4tgrSolidMap.cend()) << 186 G4tgrSolid* G4tgrVolumeMgr::FindSolid( const G4String& volname, G4bool exists )
>> 187 {
>> 188 G4tgrSolid* vol = 0;
>> 189
>> 190 G4mapssol::iterator svite = theG4tgrSolidMap.find( volname );
>> 191 if( svite == theG4tgrSolidMap.end() )
196 { 192 {
197 if(exists) << 193 if( exists )
198 { 194 {
199 for(svite = theG4tgrSolidMap.cbegin(); << 195 for( svite = theG4tgrSolidMap.begin();
200 svite != theG4tgrSolidMap.cend(); ++ << 196 svite != theG4tgrSolidMap.end(); svite++ )
201 { 197 {
202 G4cerr << " VOL:" << (*svite).first << 198 G4cerr << " VOL:" << (*svite).first << G4endl;
203 } 199 }
204 G4String ErrMessage = "Solid not found.. 200 G4String ErrMessage = "Solid not found... " + volname;
205 G4Exception("G4tgrVolumeMgr::FindSolid() << 201 G4Exception("G4tgrVolumeMgr::FindSolid()", "InvalidSetup",
206 ErrMessage); << 202 FatalException, ErrMessage);
207 } 203 }
208 } 204 }
209 else 205 else
210 { 206 {
211 vol = const_cast<G4tgrSolid*>((*svite).sec 207 vol = const_cast<G4tgrSolid*>((*svite).second);
212 } 208 }
213 209
214 return vol; 210 return vol;
215 } 211 }
216 212
217 // ------------------------------------------- <<
218 G4tgrVolume* G4tgrVolumeMgr::FindVolume(const <<
219 { <<
220 G4tgrVolume* vol = nullptr; <<
221 213
222 G4mapsvol::const_iterator svite = theG4tgrVo << 214 //-------------------------------------------------------------
223 if(svite == theG4tgrVolumeMap.cend()) << 215 G4tgrVolume*
>> 216 G4tgrVolumeMgr::FindVolume( const G4String& volname, G4bool exists )
>> 217 {
>> 218 G4tgrVolume* vol = 0;
>> 219
>> 220 G4mapsvol::iterator svite = theG4tgrVolumeMap.find( volname );
>> 221 if( svite == theG4tgrVolumeMap.end() )
224 { 222 {
225 if(exists) << 223 if( exists )
226 { 224 {
227 for(svite = theG4tgrVolumeMap.cbegin(); << 225 for( svite = theG4tgrVolumeMap.begin();
228 svite != theG4tgrVolumeMap.cend(); + << 226 svite != theG4tgrVolumeMap.end(); svite++ )
229 { 227 {
230 G4cerr << " VOL:" << (*svite).first << 228 G4cerr << " VOL:" << (*svite).first << G4endl;
231 } 229 }
232 G4String ErrMessage = "Volume not found. 230 G4String ErrMessage = "Volume not found... " + volname;
233 G4Exception("G4tgrVolumeMgr::FindVolume( 231 G4Exception("G4tgrVolumeMgr::FindVolume()", "InvalidSetup",
234 FatalException, ErrMessage); 232 FatalException, ErrMessage);
235 } 233 }
236 else 234 else
237 { 235 {
238 G4String WarMessage = "Volume does not e 236 G4String WarMessage = "Volume does not exists... " + volname;
239 G4Exception("G4tgrVolumeMgr::FindVolume( << 237 G4Exception("G4tgrVolumeMgr::FindVolume()", "SearchFailed",
240 WarMessage); << 238 JustWarning, WarMessage);
241 } 239 }
242 } 240 }
243 else 241 else
244 { 242 {
245 vol = const_cast<G4tgrVolume*>((*svite).se 243 vol = const_cast<G4tgrVolume*>((*svite).second);
246 } 244 }
247 245
248 return vol; 246 return vol;
249 } 247 }
250 248
251 // ------------------------------------------- << 249 //-------------------------------------------------------------
252 std::vector<G4tgrVolume*> G4tgrVolumeMgr::Find << 250 std::vector<G4tgrVolume*>
253 << 251 G4tgrVolumeMgr::FindVolumes( const G4String& volname, G4bool exists )
254 { 252 {
255 std::vector<G4tgrVolume*> vols; 253 std::vector<G4tgrVolume*> vols;
256 << 254
257 G4mapsvol::const_iterator svite; << 255 G4mapsvol::iterator svite;
258 for(svite = theG4tgrVolumeMap.cbegin(); << 256 for( svite = theG4tgrVolumeMap.begin();
259 svite != theG4tgrVolumeMap.cend(); ++svi << 257 svite != theG4tgrVolumeMap.end(); svite++ )
260 { 258 {
261 if(G4tgrUtils::AreWordsEquivalent(volname, << 259 if( G4tgrUtils::AreWordsEquivalent( volname, (*svite).second->GetName()) )
262 { 260 {
263 vols.push_back(const_cast<G4tgrVolume*>( << 261 vols.push_back(const_cast<G4tgrVolume*>((*svite).second) );
264 } 262 }
265 } 263 }
266 264
267 if(vols.size() == 0) << 265 if( vols.size() == 0 )
268 { 266 {
269 if(exists) << 267 if( exists )
270 { 268 {
271 for(svite = theG4tgrVolumeMap.cbegin(); << 269 for( svite = theG4tgrVolumeMap.begin();
272 svite != theG4tgrVolumeMap.cend(); + << 270 svite != theG4tgrVolumeMap.end(); svite++ )
273 { 271 {
274 G4cerr << " VOL:" << (*svite).first << 272 G4cerr << " VOL:" << (*svite).first << G4endl;
275 } 273 }
276 G4String ErrMessage = "Volume not found. 274 G4String ErrMessage = "Volume not found... " + volname;
277 G4Exception("G4tgrVolumeMgr::FindVolumes 275 G4Exception("G4tgrVolumeMgr::FindVolumes()", "InvalidSetup",
278 FatalException, ErrMessage); 276 FatalException, ErrMessage);
279 } 277 }
280 else 278 else
281 { 279 {
282 G4String WarMessage = "Volume does not e 280 G4String WarMessage = "Volume does not exists... " + volname;
283 G4Exception("G4tgrVolumeMgr::FindVolumes << 281 G4Exception("G4tgrVolumeMgr::FindVolumes()", "SearchFailed",
284 WarMessage); << 282 JustWarning, WarMessage);
285 } 283 }
286 } 284 }
287 285
288 return vols; 286 return vols;
289 } 287 }
290 288
291 // ------------------------------------------- << 289
>> 290 //-------------------------------------------------------------
292 const G4tgrVolume* G4tgrVolumeMgr::GetTopVolum 291 const G4tgrVolume* G4tgrVolumeMgr::GetTopVolume()
293 { 292 {
294 //--- Start from any G4tgrVolume and go upwa 293 //--- Start from any G4tgrVolume and go upwards until you get to the top.
295 // Check that indeed all volumes drive to << 294 // Check that indeed all volumes drive to the same top volume
296 295
297 const G4tgrVolume* topVol = nullptr; << 296 const G4tgrVolume* topVol = 0;
298 for(auto itetv = theG4tgrVolumeMap.cbegin(); << 297 G4mapsvol::const_iterator itetv;
299 itetv != theG4tgrVolumeMap.cend(); << 298 for( itetv = theG4tgrVolumeMap.begin();
>> 299 itetv != theG4tgrVolumeMap.end(); itetv++ )
300 { 300 {
301 const G4tgrVolume* vol = (*itetv).second; 301 const G4tgrVolume* vol = (*itetv).second;
302 #ifdef G4VERBOSE 302 #ifdef G4VERBOSE
303 if(G4tgrMessenger::GetVerboseLevel() >= 3) << 303 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
304 { 304 {
305 G4cout << " G4tgrVolumeMgr::GetTopVolume << 305 G4cout << " G4tgrVolumeMgr::GetTopVolume() - Vol: "
306 << " no place = " << vol->GetPlac << 306 << vol->GetName() << " no place = "
>> 307 << vol->GetPlacements().size() << G4endl;
307 } 308 }
308 #endif 309 #endif
309 << 310
310 while(vol->GetPlacements().size() != 0) << 311 while( vol->GetPlacements().size() != 0 )
311 { 312 {
312 vol = FindVolume((*(vol->GetPlacements() << 313 vol = FindVolume((*(vol->GetPlacements()).begin())->GetParentName(), 1);
313 #ifdef G4VERBOSE 314 #ifdef G4VERBOSE
314 if(G4tgrMessenger::GetVerboseLevel() >= << 315 if( G4tgrMessenger::GetVerboseLevel() >= 3 )
315 { 316 {
316 G4cout << " G4tgrVolumeMgr::GetTopVolu << 317 G4cout << " G4tgrVolumeMgr::GetTopVolume() - Vol: "
317 << " N place = " << vol->GetPla << 318 << vol->GetName()<< " N place = "
>> 319 << vol->GetPlacements().size() << G4endl;
318 } 320 }
319 #endif 321 #endif
320 } 322 }
321 if((topVol != nullptr) && (topVol != vol) << 323 if ( (topVol != 0) && (topVol != vol)
322 (topVol->GetType() != "VOLDivision") && << 324 && (topVol->GetType() != "VOLDivision")
323 (vol->GetType() != "VOLDivision")) << 325 && (vol->GetType() != "VOLDivision") )
324 { 326 {
325 G4Exception("G4tgrVolumeMgr::GetTopVolum 327 G4Exception("G4tgrVolumeMgr::GetTopVolume()",
326 "Two world volumes found, se 328 "Two world volumes found, second will be taken", JustWarning,
327 (G4String("Both volumes are << 329 (G4String("Both volumes are at the top of a hierarchy: ")
328 topVol->GetName() + " & " + << 330 + topVol->GetName() + " & " + vol->GetName() ).c_str());
329 .c_str()); <<
330 } 331 }
331 topVol = vol; 332 topVol = vol;
332 } 333 }
333 334
334 return topVol; 335 return topVol;
335 } 336 }
336 337
337 // ------------------------------------------- << 338
>> 339 //-------------------------------------------------------------
338 std::pair<G4mmapspl::iterator, G4mmapspl::iter 340 std::pair<G4mmapspl::iterator, G4mmapspl::iterator>
339 G4tgrVolumeMgr::GetChildren(const G4String& na << 341 G4tgrVolumeMgr::GetChildren( const G4String& name )
340 { 342 {
341 std::pair<G4mmapspl::iterator, G4mmapspl::it 343 std::pair<G4mmapspl::iterator, G4mmapspl::iterator> dite;
342 dite = theG4tgrVolumeTree.equal_range(name); << 344 dite = theG4tgrVolumeTree.equal_range( name );
343 return dite; 345 return dite;
344 } 346 }
345 347
346 // ------------------------------------------- << 348
>> 349 //-------------------------------------------------------------
347 void G4tgrVolumeMgr::DumpVolumeTree() 350 void G4tgrVolumeMgr::DumpVolumeTree()
348 { 351 {
349 G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrVo 352 G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrVolume's Tree " << G4endl;
350 353
351 const G4tgrVolume* vol = GetTopVolume(); 354 const G4tgrVolume* vol = GetTopVolume();
352 355
353 DumpVolumeLeaf(vol, 0, 0); << 356 DumpVolumeLeaf( vol, 0, 0);
354 } 357 }
355 358
356 // ------------------------------------------- << 359
357 void G4tgrVolumeMgr::DumpVolumeLeaf(const G4tg << 360 //-------------------------------------------------------------
358 unsigned i << 361 void G4tgrVolumeMgr::DumpVolumeLeaf( const G4tgrVolume* vol,
>> 362 unsigned int copyNo,
>> 363 unsigned int leafDepth)
359 { 364 {
360 for(std::size_t ii = 0; ii < leafDepth; ++ii << 365 for( size_t ii=0; ii < leafDepth; ii++ )
361 { 366 {
362 G4cout << " "; 367 G4cout << " ";
363 } 368 }
364 G4cout << " VOL:(" << leafDepth << ")" << vo << 369 G4cout << " VOL:(" << leafDepth << ")" << vol->GetName()
365 << copyNo << G4endl; << 370 << " copy No " << copyNo << G4endl;
366 371
367 //---------- construct the children of this 372 //---------- construct the children of this VOL
368 std::pair<G4mmapspl::iterator, G4mmapspl::it << 373 std::pair<G4mmapspl::iterator, G4mmapspl::iterator> children
369 GetChildren(vol->GetName()); << 374 = GetChildren( vol->GetName() );
370 G4mmapspl::const_iterator cite; << 375 G4mmapspl::const_iterator cite;
371 376
372 ++leafDepth; << 377 leafDepth++;
373 for(cite = children.first; cite != children. << 378 for( cite = children.first; cite != children.second; cite++ )
374 { 379 {
375 //---- find G4tgrVolume pointed by G4tgrPl 380 //---- find G4tgrVolume pointed by G4tgrPlace
376 const G4tgrPlace* pla = (*cite).seco << 381 const G4tgrPlace* pla = (*cite).second;
377 const G4tgrVolume* volchild = pla->GetVolu 382 const G4tgrVolume* volchild = pla->GetVolume();
378 //--- find copyNo 383 //--- find copyNo
379 unsigned int cn = pla->GetCopyNo(); 384 unsigned int cn = pla->GetCopyNo();
380 DumpVolumeLeaf(volchild, cn, leafDepth); << 385 DumpVolumeLeaf( volchild, cn, leafDepth );
381 } 386 }
382 } 387 }
383 388
384 // ------------------------------------------- << 389
>> 390 //-------------------------------------------------------------
385 void G4tgrVolumeMgr::DumpSummary() 391 void G4tgrVolumeMgr::DumpSummary()
386 { 392 {
387 //---------- Dump number of objects of each 393 //---------- Dump number of objects of each class
388 G4cout << " @@@@@@@@@@@@@@@@@@ Dumping Detec 394 G4cout << " @@@@@@@@@@@@@@@@@@ Dumping Detector Summary " << G4endl;
389 G4cout << " @@@ Geometry built inside world 395 G4cout << " @@@ Geometry built inside world volume: "
390 << GetTopVolume()->GetName() << G4end 396 << GetTopVolume()->GetName() << G4endl;
391 G4cout << " Number of G4tgrVolume's: " << th << 397 G4cout << " Number of G4tgrVolume's: "
>> 398 << theG4tgrVolumeMap.size() << G4endl;
>> 399 G4mapsvol::const_iterator cite;
392 unsigned int nPlace = 0; 400 unsigned int nPlace = 0;
393 for(auto cite = theG4tgrVolumeMap.cbegin(); << 401 for( cite = theG4tgrVolumeMap.begin();
394 cite != theG4tgrVolumeMap.cend(); ++cite << 402 cite != theG4tgrVolumeMap.end(); cite++ )
395 { 403 {
396 nPlace += ((*cite).second)->GetPlacements( 404 nPlace += ((*cite).second)->GetPlacements().size();
397 } 405 }
398 G4cout << " Number of G4tgrPlace's: " << nPl 406 G4cout << " Number of G4tgrPlace's: " << nPlace << G4endl;
399 407
400 G4tgrMaterialFactory* matef = G4tgrMaterialF 408 G4tgrMaterialFactory* matef = G4tgrMaterialFactory::GetInstance();
401 G4cout << " Number of G4tgrIsotope's: " << m << 409 G4cout << " Number of G4tgrIsotope's: "
402 << G4endl; << 410 << matef->GetIsotopeList().size() << G4endl;
403 G4cout << " Number of G4tgrElement's: " << m << 411 G4cout << " Number of G4tgrElement's: "
404 << G4endl; << 412 << matef->GetElementList().size() << G4endl;
405 G4cout << " Number of G4tgrMaterial's: " << << 413 G4cout << " Number of G4tgrMaterial's: "
406 << G4endl; << 414 << matef->GetMaterialList().size() << G4endl;
407 415
408 G4tgrRotationMatrixFactory* rotmf = G4tgrRot 416 G4tgrRotationMatrixFactory* rotmf = G4tgrRotationMatrixFactory::GetInstance();
409 G4cout << " Number of G4tgrRotationMatrix's: 417 G4cout << " Number of G4tgrRotationMatrix's: "
410 << rotmf->GetRotMatList().size() << G 418 << rotmf->GetRotMatList().size() << G4endl;
411 419
>> 420
412 //---------- Dump detail list of objects of 421 //---------- Dump detail list of objects of each class
413 DumpVolumeTree(); 422 DumpVolumeTree();
414 << 423
415 matef->DumpIsotopeList(); 424 matef->DumpIsotopeList();
416 matef->DumpElementList(); 425 matef->DumpElementList();
417 matef->DumpMaterialList(); 426 matef->DumpMaterialList();
418 rotmf->DumpRotmList(); 427 rotmf->DumpRotmList();
419 } 428 }
420 429