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