1 | // |
---|
2 | // ******************************************************************** |
---|
3 | // * License and Disclaimer * |
---|
4 | // * * |
---|
5 | // * The Geant4 software is copyright of the Copyright Holders of * |
---|
6 | // * the Geant4 Collaboration. It is provided under the terms and * |
---|
7 | // * conditions of the Geant4 Software License, included in the file * |
---|
8 | // * LICENSE and available at http://cern.ch/geant4/license . These * |
---|
9 | // * include a list of copyright holders. * |
---|
10 | // * * |
---|
11 | // * Neither the authors of this software system, nor their employing * |
---|
12 | // * institutes,nor the agencies providing financial support for this * |
---|
13 | // * work make any representation or warranty, express or implied, * |
---|
14 | // * regarding this software system or assume any liability for its * |
---|
15 | // * use. Please see the license in the file LICENSE and URL above * |
---|
16 | // * for the full disclaimer and the limitation of liability. * |
---|
17 | // * * |
---|
18 | // * This code implementation is the result of the scientific and * |
---|
19 | // * technical work of the GEANT4 collaboration. * |
---|
20 | // * By using, copying, modifying or distributing the software (or * |
---|
21 | // * any work based on the software) you agree to acknowledge its * |
---|
22 | // * use in resulting scientific publications, and indicate your * |
---|
23 | // * acceptance of all terms of the Geant4 Software license. * |
---|
24 | // ******************************************************************** |
---|
25 | // |
---|
26 | // |
---|
27 | // $Id: G4tgrVolumeMgr.cc,v 1.7 2008/12/18 13:00:22 gunter Exp $ |
---|
28 | // GEANT4 tag $Name: geant4-09-03 $ |
---|
29 | // |
---|
30 | // |
---|
31 | // class G4tgrVolumeMgr |
---|
32 | |
---|
33 | // History: |
---|
34 | // - Created. P.Arce, CIEMAT (November 2007) |
---|
35 | // ------------------------------------------------------------------------- |
---|
36 | |
---|
37 | #include "G4tgrVolumeMgr.hh" |
---|
38 | #include "G4tgrUtils.hh" |
---|
39 | #include "G4tgrMaterialFactory.hh" |
---|
40 | #include "G4tgrRotationMatrixFactory.hh" |
---|
41 | #include "G4tgrFileReader.hh" |
---|
42 | #include "G4tgrMessenger.hh" |
---|
43 | #include "G4tgrSolid.hh" |
---|
44 | #include "G4tgrSolidBoolean.hh" |
---|
45 | |
---|
46 | |
---|
47 | G4tgrVolumeMgr* G4tgrVolumeMgr::theInstance = 0; |
---|
48 | |
---|
49 | |
---|
50 | //------------------------------------------------------------- |
---|
51 | G4tgrVolumeMgr::G4tgrVolumeMgr() |
---|
52 | { |
---|
53 | } |
---|
54 | |
---|
55 | |
---|
56 | //------------------------------------------------------------- |
---|
57 | G4tgrVolumeMgr::~G4tgrVolumeMgr() |
---|
58 | { |
---|
59 | delete theInstance; |
---|
60 | } |
---|
61 | |
---|
62 | |
---|
63 | //------------------------------------------------------------- |
---|
64 | G4tgrVolumeMgr* G4tgrVolumeMgr::GetInstance() |
---|
65 | { |
---|
66 | if( !theInstance ) |
---|
67 | { |
---|
68 | theInstance = new G4tgrVolumeMgr; |
---|
69 | } |
---|
70 | return theInstance; |
---|
71 | } |
---|
72 | |
---|
73 | |
---|
74 | //------------------------------------------------------------------- |
---|
75 | G4tgrSolid* |
---|
76 | G4tgrVolumeMgr::CreateSolid( const std::vector<G4String>& wl, G4bool bVOLUtag ) |
---|
77 | { |
---|
78 | G4tgrSolid* sol = FindSolid( wl[1] ); |
---|
79 | if( sol ) |
---|
80 | { |
---|
81 | G4String ErrMessage = "Solid already exists... " + wl[1]; |
---|
82 | G4Exception("G4tgrVolumeMgr::CreateSolid()", "InvalidSetup", |
---|
83 | FatalException, ErrMessage); |
---|
84 | } |
---|
85 | |
---|
86 | std::vector<G4String> wlc = wl; |
---|
87 | if( bVOLUtag ) { wlc.pop_back(); } |
---|
88 | |
---|
89 | G4String wl2 = wlc[2]; |
---|
90 | for( size_t ii = 0; ii < wl2.length(); ii++ ) |
---|
91 | { |
---|
92 | wl2[ii] = toupper( wl2[ii] ); |
---|
93 | } |
---|
94 | if( (wl2 == "UNION") || (wl2 == "SUBTRACTION") || (wl2 == "INTERSECTION") ) |
---|
95 | { |
---|
96 | //---------- Boolean solid |
---|
97 | //---------- Create G4tgrSolidBoolean and fill the solid params |
---|
98 | sol = new G4tgrSolidBoolean( wlc ); |
---|
99 | } |
---|
100 | else |
---|
101 | { |
---|
102 | //---------- Create G4tgrSolidSimple and fill the solid params |
---|
103 | sol = new G4tgrSolid( wlc ); |
---|
104 | } |
---|
105 | |
---|
106 | return sol; |
---|
107 | } |
---|
108 | |
---|
109 | //------------------------------------------------------------------- |
---|
110 | void G4tgrVolumeMgr::RegisterMe( G4tgrSolid* sol) |
---|
111 | { |
---|
112 | if( theG4tgrSolidMap.find( sol->GetName() ) != theG4tgrSolidMap.end() ) |
---|
113 | { |
---|
114 | G4String ErrMessage = "Cannot be two solids with the same name... " |
---|
115 | + sol->GetName(); |
---|
116 | G4Exception("G4tgrVolumeMgr::RegisterMe()", "InvalidSetup", |
---|
117 | FatalException, ErrMessage); |
---|
118 | } |
---|
119 | theG4tgrSolidMap.insert(G4mapssol::value_type(sol->GetName(), sol) ); |
---|
120 | } |
---|
121 | |
---|
122 | |
---|
123 | //------------------------------------------------------------- |
---|
124 | void G4tgrVolumeMgr::UnRegisterMe( G4tgrSolid* sol ) |
---|
125 | { |
---|
126 | if( theG4tgrSolidMap.find( sol->GetName() ) != theG4tgrSolidMap.end() ) |
---|
127 | { |
---|
128 | G4String ErrMessage = "Cannot unregister a solid that is not registered... " |
---|
129 | + sol->GetName(); |
---|
130 | G4Exception("G4tgrSolidMgr::unRegisterMe()", "InvalidSetup", |
---|
131 | FatalException, ErrMessage); |
---|
132 | } |
---|
133 | else |
---|
134 | { |
---|
135 | theG4tgrSolidMap.erase( theG4tgrSolidMap.find( sol->GetName() ) ); |
---|
136 | } |
---|
137 | } |
---|
138 | |
---|
139 | |
---|
140 | //------------------------------------------------------------- |
---|
141 | void G4tgrVolumeMgr::RegisterMe( G4tgrVolume* vol) |
---|
142 | { |
---|
143 | theG4tgrVolumeList.push_back( vol ); |
---|
144 | if( theG4tgrVolumeMap.find( vol->GetName() ) != theG4tgrVolumeMap.end() ) |
---|
145 | { |
---|
146 | G4String ErrMessage = "Cannot be two volumes with the same name... " |
---|
147 | + vol->GetName(); |
---|
148 | G4Exception("G4tgrVolumeMgr::RegisterMe()", "InvalidSetup", |
---|
149 | FatalException, ErrMessage); |
---|
150 | } |
---|
151 | theG4tgrVolumeMap.insert(G4mapsvol::value_type(vol->GetName(), vol) ); |
---|
152 | } |
---|
153 | |
---|
154 | |
---|
155 | //------------------------------------------------------------- |
---|
156 | void G4tgrVolumeMgr::UnRegisterMe( G4tgrVolume* vol ) |
---|
157 | { |
---|
158 | std::vector<G4tgrVolume*>::iterator ite; |
---|
159 | for(ite = theG4tgrVolumeList.begin(); ite != theG4tgrVolumeList.end(); ite++) |
---|
160 | { |
---|
161 | if((*ite) == vol ) { break; } |
---|
162 | } |
---|
163 | if( ite == theG4tgrVolumeList.end() ) |
---|
164 | { |
---|
165 | G4String ErrMessage = "Cannot unregister a volume not registered... " |
---|
166 | + vol->GetName(); |
---|
167 | G4Exception("G4tgrVolumeMgr::unRegisterMe()", "InvalidSetup", |
---|
168 | FatalException, ErrMessage); |
---|
169 | } |
---|
170 | else |
---|
171 | { |
---|
172 | theG4tgrVolumeList.erase( ite ); |
---|
173 | } |
---|
174 | theG4tgrVolumeMap.erase( theG4tgrVolumeMap.find( vol->GetName() ) ); |
---|
175 | } |
---|
176 | |
---|
177 | |
---|
178 | //------------------------------------------------------------- |
---|
179 | |
---|
180 | void G4tgrVolumeMgr::RegisterParentChild( const G4String& parentName, |
---|
181 | const G4tgrPlace* pl ) |
---|
182 | { |
---|
183 | theG4tgrVolumeTree.insert(G4mmapspl::value_type(parentName, pl) ); |
---|
184 | } |
---|
185 | |
---|
186 | |
---|
187 | //------------------------------------------------------------- |
---|
188 | G4tgrSolid* G4tgrVolumeMgr::FindSolid( const G4String& volname, G4bool exists ) |
---|
189 | { |
---|
190 | G4tgrSolid* vol = 0; |
---|
191 | |
---|
192 | G4mapssol::iterator svite = theG4tgrSolidMap.find( volname ); |
---|
193 | if( svite == theG4tgrSolidMap.end() ) |
---|
194 | { |
---|
195 | if( exists ) |
---|
196 | { |
---|
197 | for( svite = theG4tgrSolidMap.begin(); |
---|
198 | svite != theG4tgrSolidMap.end(); svite++ ) |
---|
199 | { |
---|
200 | G4cerr << " VOL:" << (*svite).first << G4endl; |
---|
201 | } |
---|
202 | G4String ErrMessage = "Solid not found... " + volname; |
---|
203 | G4Exception("G4tgrVolumeMgr::FindSolid()", "InvalidSetup", |
---|
204 | FatalException, ErrMessage); |
---|
205 | } |
---|
206 | } |
---|
207 | else |
---|
208 | { |
---|
209 | vol = const_cast<G4tgrSolid*>((*svite).second); |
---|
210 | } |
---|
211 | |
---|
212 | return vol; |
---|
213 | } |
---|
214 | |
---|
215 | |
---|
216 | //------------------------------------------------------------- |
---|
217 | G4tgrVolume* |
---|
218 | G4tgrVolumeMgr::FindVolume( const G4String& volname, G4bool exists ) |
---|
219 | { |
---|
220 | G4tgrVolume* vol = 0; |
---|
221 | |
---|
222 | G4mapsvol::iterator svite = theG4tgrVolumeMap.find( volname ); |
---|
223 | if( svite == theG4tgrVolumeMap.end() ) |
---|
224 | { |
---|
225 | if( exists ) |
---|
226 | { |
---|
227 | for( svite = theG4tgrVolumeMap.begin(); |
---|
228 | svite != theG4tgrVolumeMap.end(); svite++ ) |
---|
229 | { |
---|
230 | G4cerr << " VOL:" << (*svite).first << G4endl; |
---|
231 | } |
---|
232 | G4String ErrMessage = "Volume not found... " + volname; |
---|
233 | G4Exception("G4tgrVolumeMgr::FindVolume()", "InvalidSetup", |
---|
234 | FatalException, ErrMessage); |
---|
235 | } |
---|
236 | else |
---|
237 | { |
---|
238 | G4String WarMessage = "Volume does not exists... " + volname; |
---|
239 | G4Exception("G4tgrVolumeMgr::FindVolume()", "SearchFailed", |
---|
240 | JustWarning, WarMessage); |
---|
241 | } |
---|
242 | } |
---|
243 | else |
---|
244 | { |
---|
245 | vol = const_cast<G4tgrVolume*>((*svite).second); |
---|
246 | } |
---|
247 | |
---|
248 | return vol; |
---|
249 | } |
---|
250 | |
---|
251 | //------------------------------------------------------------- |
---|
252 | std::vector<G4tgrVolume*> |
---|
253 | G4tgrVolumeMgr::FindVolumes( const G4String& volname, G4bool exists ) |
---|
254 | { |
---|
255 | std::vector<G4tgrVolume*> vols; |
---|
256 | |
---|
257 | G4mapsvol::iterator svite; |
---|
258 | for( svite = theG4tgrVolumeMap.begin(); |
---|
259 | svite != theG4tgrVolumeMap.end(); svite++ ) |
---|
260 | { |
---|
261 | if( G4tgrUtils::AreWordsEquivalent( volname, (*svite).second->GetName()) ) |
---|
262 | { |
---|
263 | vols.push_back(const_cast<G4tgrVolume*>((*svite).second) ); |
---|
264 | } |
---|
265 | } |
---|
266 | |
---|
267 | if( vols.size() == 0 ) |
---|
268 | { |
---|
269 | if( exists ) |
---|
270 | { |
---|
271 | for( svite = theG4tgrVolumeMap.begin(); |
---|
272 | svite != theG4tgrVolumeMap.end(); svite++ ) |
---|
273 | { |
---|
274 | G4cerr << " VOL:" << (*svite).first << G4endl; |
---|
275 | } |
---|
276 | G4String ErrMessage = "Volume not found... " + volname; |
---|
277 | G4Exception("G4tgrVolumeMgr::FindVolumes()", "InvalidSetup", |
---|
278 | FatalException, ErrMessage); |
---|
279 | } |
---|
280 | else |
---|
281 | { |
---|
282 | G4String WarMessage = "Volume does not exists... " + volname; |
---|
283 | G4Exception("G4tgrVolumeMgr::FindVolumes()", "SearchFailed", |
---|
284 | JustWarning, WarMessage); |
---|
285 | } |
---|
286 | } |
---|
287 | |
---|
288 | return vols; |
---|
289 | } |
---|
290 | |
---|
291 | |
---|
292 | //------------------------------------------------------------- |
---|
293 | const G4tgrVolume* G4tgrVolumeMgr::GetTopVolume() |
---|
294 | { |
---|
295 | //--- Start from any G4tgrVolume and go upwards until you get to the top. |
---|
296 | // Check that indeed all volumes drive to the same top volume |
---|
297 | |
---|
298 | const G4tgrVolume* topVol = 0; |
---|
299 | G4mapsvol::const_iterator itetv; |
---|
300 | for( itetv = theG4tgrVolumeMap.begin(); |
---|
301 | itetv != theG4tgrVolumeMap.end(); itetv++ ) |
---|
302 | { |
---|
303 | const G4tgrVolume* vol = (*itetv).second; |
---|
304 | #ifdef G4VERBOSE |
---|
305 | if( G4tgrMessenger::GetVerboseLevel() >= 3 ) |
---|
306 | { |
---|
307 | G4cout << " G4tgrVolumeMgr::GetTopVolume() - Vol: " |
---|
308 | << vol->GetName() << " no place = " |
---|
309 | << vol->GetPlacements().size() << G4endl; |
---|
310 | } |
---|
311 | #endif |
---|
312 | |
---|
313 | while( vol->GetPlacements().size() != 0 ) |
---|
314 | { |
---|
315 | vol = FindVolume((*(vol->GetPlacements()).begin())->GetParentName(), 1); |
---|
316 | #ifdef G4VERBOSE |
---|
317 | if( G4tgrMessenger::GetVerboseLevel() >= 3 ) |
---|
318 | { |
---|
319 | G4cout << " G4tgrVolumeMgr::GetTopVolume() - Vol: " |
---|
320 | << vol->GetName()<< " N place = " |
---|
321 | << vol->GetPlacements().size() << G4endl; |
---|
322 | } |
---|
323 | #endif |
---|
324 | } |
---|
325 | if ( (topVol != 0) && (topVol != vol) |
---|
326 | && (topVol->GetType() != "VOLDivision") |
---|
327 | && (vol->GetType() != "VOLDivision") ) |
---|
328 | { |
---|
329 | G4Exception("G4tgrVolumeMgr::GetTopVolume()", |
---|
330 | "Two world volumes found, second will be taken", JustWarning, |
---|
331 | (G4String("Both volumes are at the top of a hierarchy: ") |
---|
332 | + topVol->GetName() + " & " + vol->GetName() ).c_str()); |
---|
333 | } |
---|
334 | topVol = vol; |
---|
335 | } |
---|
336 | |
---|
337 | return topVol; |
---|
338 | } |
---|
339 | |
---|
340 | |
---|
341 | //------------------------------------------------------------- |
---|
342 | std::pair<G4mmapspl::iterator, G4mmapspl::iterator> |
---|
343 | G4tgrVolumeMgr::GetChildren( const G4String& name ) |
---|
344 | { |
---|
345 | std::pair<G4mmapspl::iterator, G4mmapspl::iterator> dite; |
---|
346 | dite = theG4tgrVolumeTree.equal_range( name ); |
---|
347 | return dite; |
---|
348 | } |
---|
349 | |
---|
350 | |
---|
351 | //------------------------------------------------------------- |
---|
352 | void G4tgrVolumeMgr::DumpVolumeTree() |
---|
353 | { |
---|
354 | G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrVolume's Tree " << G4endl; |
---|
355 | |
---|
356 | const G4tgrVolume* vol = GetTopVolume(); |
---|
357 | |
---|
358 | DumpVolumeLeaf( vol, 0, 0); |
---|
359 | } |
---|
360 | |
---|
361 | |
---|
362 | //------------------------------------------------------------- |
---|
363 | void G4tgrVolumeMgr::DumpVolumeLeaf( const G4tgrVolume* vol, |
---|
364 | unsigned int copyNo, |
---|
365 | unsigned int leafDepth) |
---|
366 | { |
---|
367 | for( size_t ii=0; ii < leafDepth; ii++ ) |
---|
368 | { |
---|
369 | G4cout << " "; |
---|
370 | } |
---|
371 | G4cout << " VOL:(" << leafDepth << ")" << vol->GetName() |
---|
372 | << " copy No " << copyNo << G4endl; |
---|
373 | |
---|
374 | //---------- construct the children of this VOL |
---|
375 | std::pair<G4mmapspl::const_iterator, G4mmapspl::const_iterator> children |
---|
376 | = GetChildren( vol->GetName() ); |
---|
377 | G4mmapspl::const_iterator cite; |
---|
378 | |
---|
379 | leafDepth++; |
---|
380 | for( cite = children.first; cite != children.second; cite++ ) |
---|
381 | { |
---|
382 | //---- find G4tgrVolume pointed by G4tgrPlace |
---|
383 | const G4tgrPlace* pla = (*cite).second; |
---|
384 | const G4tgrVolume* volchild = pla->GetVolume(); |
---|
385 | //--- find copyNo |
---|
386 | unsigned int cn = pla->GetCopyNo(); |
---|
387 | DumpVolumeLeaf( volchild, cn, leafDepth ); |
---|
388 | } |
---|
389 | } |
---|
390 | |
---|
391 | |
---|
392 | //------------------------------------------------------------- |
---|
393 | void G4tgrVolumeMgr::DumpSummary() |
---|
394 | { |
---|
395 | //---------- Dump number of objects of each class |
---|
396 | G4cout << " @@@@@@@@@@@@@@@@@@ Dumping Detector Summary " << G4endl; |
---|
397 | G4cout << " @@@ Geometry built inside world volume: " |
---|
398 | << GetTopVolume()->GetName() << G4endl; |
---|
399 | G4cout << " Number of G4tgrVolume's: " |
---|
400 | << theG4tgrVolumeMap.size() << G4endl; |
---|
401 | G4mapsvol::const_iterator cite; |
---|
402 | unsigned int nPlace = 0; |
---|
403 | for( cite = theG4tgrVolumeMap.begin(); |
---|
404 | cite != theG4tgrVolumeMap.end(); cite++ ) |
---|
405 | { |
---|
406 | nPlace += ((*cite).second)->GetPlacements().size(); |
---|
407 | } |
---|
408 | G4cout << " Number of G4tgrPlace's: " << nPlace << G4endl; |
---|
409 | |
---|
410 | G4tgrMaterialFactory* matef = G4tgrMaterialFactory::GetInstance(); |
---|
411 | G4cout << " Number of G4tgrIsotope's: " |
---|
412 | << matef->GetIsotopeList().size() << G4endl; |
---|
413 | G4cout << " Number of G4tgrElement's: " |
---|
414 | << matef->GetElementList().size() << G4endl; |
---|
415 | G4cout << " Number of G4tgrMaterial's: " |
---|
416 | << matef->GetMaterialList().size() << G4endl; |
---|
417 | |
---|
418 | G4tgrRotationMatrixFactory* rotmf = G4tgrRotationMatrixFactory::GetInstance(); |
---|
419 | G4cout << " Number of G4tgrRotationMatrix's: " |
---|
420 | << rotmf->GetRotMatList().size() << G4endl; |
---|
421 | |
---|
422 | |
---|
423 | //---------- Dump detail list of objects of each class |
---|
424 | DumpVolumeTree(); |
---|
425 | |
---|
426 | matef->DumpIsotopeList(); |
---|
427 | matef->DumpElementList(); |
---|
428 | matef->DumpMaterialList(); |
---|
429 | rotmf->DumpRotmList(); |
---|
430 | } |
---|