| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // G4tgbVolumeMgr implementation
27 //
28 // Author: P.Arce, CIEMAT (November 2007)
29 // -------------------------------------------
30
31 #include "G4tgbVolumeMgr.hh"
32
33 #include "G4SystemOfUnits.hh"
34 #include "G4tgbVolume.hh"
35 #include "G4tgbMaterialMgr.hh"
36 #include "G4tgbRotationMatrixMgr.hh"
37
38 #include "G4tgrVolumeMgr.hh"
39 #include "G4tgrFileReader.hh"
40 #include "G4tgrUtils.hh"
41
42 #include "G4VSolid.hh"
43 #include "G4PhysicalVolumeStore.hh"
44 #include "G4ReflectionFactory.hh"
45 #include "G4tgrMessenger.hh"
46 #include "G4tgbDetectorBuilder.hh"
47
48 G4ThreadLocal G4tgbVolumeMgr* G4tgbVolumeMgr::
49
50 // -------------------------------------------
51 G4tgbVolumeMgr::G4tgbVolumeMgr()
52 {
53 G4ReflectionFactory::Instance()->SetScalePre
54 // NOTE: problems building matrices with not
55 // like :ROTM RR30 0.866025 0.5 0. -0.5 0.8
56 theDetectorBuilder = new G4tgbDetectorBuilde
57 }
58
59 // -------------------------------------------
60 G4tgbVolumeMgr::~G4tgbVolumeMgr()
61 {
62 delete theDetectorBuilder;
63 delete theInstance;
64 }
65
66 // -------------------------------------------
67 G4tgbVolumeMgr* G4tgbVolumeMgr::GetInstance()
68 {
69 if(theInstance == nullptr)
70 {
71 theInstance = new G4tgbVolumeMgr();
72 }
73 return theInstance;
74 }
75
76 // -------------------------------------------
77 void G4tgbVolumeMgr::AddTextFile(const G4Strin
78 {
79 G4tgrFileReader::GetInstance()->AddTextFile(
80 }
81
82 // -------------------------------------------
83 G4VPhysicalVolume* G4tgbVolumeMgr::ReadAndCons
84 {
85 const G4tgrVolume* tgrVoltop = theDetectorBu
86 return theDetectorBuilder->ConstructDetector
87 }
88
89 // -------------------------------------------
90 void G4tgbVolumeMgr::RegisterMe(const G4tgbVol
91 {
92 theVolumeList.insert(
93 G4mssvol::value_type(vol->GetName(), const
94 }
95
96 // -------------------------------------------
97 void G4tgbVolumeMgr::RegisterMe(const G4VSolid
98 {
99 theSolids.insert(
100 G4mmssol::value_type(solid->GetName(), con
101 }
102
103 // -------------------------------------------
104 void G4tgbVolumeMgr::RegisterMe(const G4Logica
105 {
106 theLVs.insert(
107 G4mmslv::value_type(lv->GetName(), const_c
108
109 #ifdef G4VERBOSE
110 if(G4tgrMessenger::GetVerboseLevel() >= 2)
111 {
112 G4cout << " G4tgbVolumeMgr::RegisterMe() -
113 << lv->GetName() << G4endl;
114 }
115 #endif
116 }
117
118 // -------------------------------------------
119 void G4tgbVolumeMgr::RegisterMe(const G4VPhysi
120 {
121 thePVs.insert(
122 G4mmspv::value_type(pv->GetName(), const_c
123 }
124
125 // -------------------------------------------
126 void G4tgbVolumeMgr::RegisterChildParentLVs(co
127 co
128 {
129 theLVInvTree[const_cast<G4LogicalVolume*>(lo
130 const_cast<G4LogicalVolume*>(parentLV);
131 theLVTree[const_cast<G4LogicalVolume*>(paren
132 const_cast<G4LogicalVolume*>(logvol);
133 }
134
135 // -------------------------------------------
136 void G4tgbVolumeMgr::CopyVolumes()
137 {
138 //--------- Loop G4tgbVolume's and create a
139 G4mapsvol vollist = G4tgrVolumeMgr::GetInsta
140 for(auto cite = vollist.cbegin(); cite != vo
141 {
142 G4tgrVolume* tgrvol = const_cast<G4tgrVolu
143 G4tgbVolume* svol = new G4tgbVolume(tgrv
144 RegisterMe(svol);
145 }
146 }
147
148 // -------------------------------------------
149 G4tgbVolume* G4tgbVolumeMgr::FindVolume(const
150 {
151 G4mssvol::const_iterator cite = theVolumeLis
152 if(cite == theVolumeList.cend())
153 {
154 G4String ErrMessage = "G4tgbVolume not fou
155 G4Exception("G4tgbVolumeMgr::FindVolume()"
156 ErrMessage);
157 return nullptr;
158 }
159 else
160 {
161 return (*cite).second;
162 }
163 }
164
165 // -------------------------------------------
166 G4VSolid* G4tgbVolumeMgr::FindG4Solid(const G4
167 {
168 #ifdef G4VERBOSE
169 if(G4tgrMessenger::GetVerboseLevel() >= 2)
170 {
171 G4cout << " G4tgbVolumeMgr::FindG4Solid()
172 }
173 #endif
174
175 G4VSolid* oldSolid = nullptr;
176 std::pair<G4mmssol::iterator, G4mmssol::iter
177 mmssdi = theSolids.equal_range(name);
178
179 if(mmssdi.first != mmssdi.second)
180 { // check there is a solid found
181 G4mmssol::const_iterator mmsscite = mmssdi
182
183 #ifdef G4VERBOSE
184 if(G4tgrMessenger::GetVerboseLevel() >= 2)
185 {
186 G4cout << " G4tgbVolumeMgr::FindG4Solid(
187 << G4endl;
188 }
189 #endif
190 /*
191 G4VSolid overwrites the operator== comp
192 => this cannot be used !!
193 Then just compare solids by name =>> PO
194 for the moment ...
195 if( solid == *( (*mmsscite).second )
196 {
197 oldSolid = (*mmsscite).second;
198 break;
199 }
200 until we write operator== for each soli
201 with the same name (therefore we will n
202 equal name and different parameters (PO
203 */
204 oldSolid = (*mmsscite).second;
205 #ifdef G4VERBOSE
206 if(G4tgrMessenger::GetVerboseLevel() >= 1)
207 {
208 G4cout << " G4tgbVolumeMgr::FindG4Solid(
209 << G4endl;
210 }
211 #endif
212 }
213
214 #ifdef G4VERBOSE
215 if(G4tgrMessenger::GetVerboseLevel() >= 2)
216 {
217 G4cout << " G4tgbVolumeMgr::FindG4Solid()
218 << G4endl;
219 }
220 #endif
221
222 return oldSolid;
223 }
224
225 // -------------------------------------------
226 G4LogicalVolume* G4tgbVolumeMgr::FindG4LogVol(
227
228 {
229 G4mmslv::const_iterator mscite = theLVs.find
230 if(mscite == theLVs.cend())
231 {
232 if(exists)
233 {
234 G4String ErrMessage = "Logical volume na
235 G4Exception("G4tgbVolumeMgr::FindG4LogVo
236 FatalException, ErrMessage);
237 }
238 return nullptr;
239 }
240 else
241 {
242 return (*mscite).second;
243 }
244 }
245
246 // -------------------------------------------
247 G4VPhysicalVolume* G4tgbVolumeMgr::FindG4PhysV
248
249 {
250 G4mmspv::const_iterator mscite = thePVs.find
251 if(mscite == thePVs.cend())
252 {
253 if(exists)
254 {
255 G4String ErrMessage = "Physical volume n
256 G4Exception("G4tgbVolumeMgr::FindG4PhysV
257 FatalException, ErrMessage);
258 }
259 return nullptr;
260 }
261 else
262 {
263 return (*mscite).second;
264 }
265 }
266
267 // -------------------------------------------
268 G4VPhysicalVolume* G4tgbVolumeMgr::GetTopPhysV
269 {
270 G4LogicalVolume* lv = GetTopLogVol();
271 G4VPhysicalVolume* pv = (*(thePVs.find(lv->G
272
273 #ifdef G4VERBOSE
274 if(G4tgrMessenger::GetVerboseLevel() >= 2)
275 {
276 G4cout << " G4tgbVolumeMgr::GetTopPhysVol(
277 << G4endl;
278 }
279 #endif
280
281 return pv;
282 }
283
284 // -------------------------------------------
285 G4LogicalVolume* G4tgbVolumeMgr::GetTopLogVol(
286 {
287 //----------- Start from any G4LogicalVolume
288 // you will always end at the top
289 #ifdef G4VERBOSE
290 if(G4tgrMessenger::GetVerboseLevel() >= 2)
291 {
292 G4cout << " G4tgbVolumeMgr::GetTopLogVol t
293 << theLVInvTree.size() << G4endl;
294 }
295 #endif
296 if(theLVInvTree.size() == 0)
297 {
298 G4Exception("G4tgbVolumeMgr::GetTopLogVol(
299 FatalException, "theLVInvTree
300 }
301 G4LogicalVolume* lv = (*(theLVInvTree.begin(
302
303 //------- if first element is the top LV, it
304 if(lv == nullptr)
305 {
306 lv = (*(theLVInvTree.begin())).first;
307 }
308 else
309 {
310 while((*(theLVInvTree.find(lv))).second !=
311 {
312 //---------- get parent of first positio
313 lv = (*(theLVInvTree.find(lv))).second;
314 #ifdef G4VERBOSE
315 if(G4tgrMessenger::GetVerboseLevel() >=
316 {
317 G4cout << " G4tgbVolumeMgr::GetTopPhys
318 << G4endl;
319 }
320 #endif
321 }
322 }
323
324 return lv;
325 }
326
327 // -------------------------------------------
328 void G4tgbVolumeMgr::BuildPhysVolTree()
329 {
330 /*
331 G4PhysicalVolumeStore* pvs = G4PhysicalVol
332 for( auto cite = pvs->cbegin(); cite != pv
333 {
334 thePVTree[ *cite ] = (*cite)->GetMother(
335 thePVInvTree[ (*cite)->GetMother() ] = *
336 }
337 */
338 }
339
340 // -------------------------------------------
341 void G4tgbVolumeMgr::DumpSummary()
342 {
343 //---------- Dump number of objects of each
344 G4cout << " @@@@@@@@@@@@@ Dumping Geant4 geo
345 G4cout << " @@@ Geometry built inside world
346 << GetTopPhysVol()->GetName() << G4en
347 G4cout << " Number of G4VSolid's: " << theSo
348 G4cout << " Number of G4LogicalVolume's: " <
349 G4cout << " Number of G4VPhysicalVolume's: "
350
351 G4tgbMaterialMgr* mateMgr = G4tgbMaterialMgr
352 G4cout << " Number of G4Isotope's: " << mate
353 << G4endl;
354 G4cout << " Number of G4Element's: " << mate
355 << G4endl;
356 G4cout << " Number of G4Material's: " << mat
357 << G4endl;
358
359 G4tgbRotationMatrixMgr* rotmMgr = G4tgbRotat
360 G4cout << " Number of G4RotationMatrix's: "
361 << rotmMgr->GetG4RotMatList().size()
362
363 //---------- Dump list of objects of each cl
364 DumpG4SolidList();
365 DumpG4LogVolTree();
366 DumpG4PhysVolTree();
367 }
368
369 // -------------------------------------------
370 void G4tgbVolumeMgr::DumpG4SolidList()
371 {
372 for(auto cite = theSolids.cbegin(); cite !=
373 {
374 G4cout << "G4SOLID: " << (*cite).second->G
375 << (*cite).second->GetEntityType()
376 }
377 }
378
379 //--------------------------------------------
380 void G4tgbVolumeMgr::DumpG4LogVolTree()
381 {
382 G4cout << " @@@@@@@@@@@@@ DUMPING G4LogicalV
383
384 G4LogicalVolume* lv = GetTopLogVol();
385
386 DumpG4LogVolLeaf(lv, 0);
387 }
388
389 //--------------------------------------------
390 void G4tgbVolumeMgr::DumpG4LogVolLeaf(const G4
391 unsigned
392 {
393 for(std::size_t ii = 0; ii < leafDepth; ++ii
394 {
395 G4cout << " ";
396 }
397 G4cout << " LV:(" << leafDepth << ")" << lv-
398
399 //---------- construct the children of this
400 // G4LogicalVolume* lvnc = const_cast<G4Logi
401 // std::pair<G4mlvlv::iterator, G4mlvlv::ite
402 // = theLVTree.equal_range( lvnc );
403 //
404 // G4mlvlv::iterator cite;
405
406 ++leafDepth;
407 // for( cite = children.first; cite != child
408 // {
409 // DumpG4LVLeaf( (*cite)->second, leafDepth
410 // }
411 }
412
413 // -------------------------------------------
414 void G4tgbVolumeMgr::DumpG4PhysVolTree()
415 {
416 G4cout << " @@@@@@@@@@@@@ DUMPING G4Physical
417
418 G4VPhysicalVolume* pv = GetTopPhysVol();
419
420 DumpG4PhysVolLeaf(pv, 0);
421 }
422
423 // -------------------------------------------
424 void G4tgbVolumeMgr::DumpG4PhysVolLeaf(const G
425 unsigne
426 {
427 for(std::size_t ii = 0; ii < leafDepth; ++ii
428 {
429 G4cout << " ";
430 }
431 G4cout << " PV:(" << leafDepth << ")" << pv-
432
433 //---------- construct the children of this
434 // G4VPhysicalVolume* pvnc = const_cast<G4VP
435 // std::pair<G4mpvpv::iterator, G4mpvpv::ite
436 // = thePVTree.equal_range( pvnc );
437 //
438 // G4mpvpv::iterator cite;
439
440 ++leafDepth;
441 // for( cite = children.first; cite != child
442 // {
443 // DumpG4PVLeaf( (*cite)->second, leafDepth
444 // }
445 }
446