source: trunk/source/persistency/ascii/src/G4tgrVolumeMgr.cc @ 1035

Last change on this file since 1035 was 1035, checked in by garnier, 15 years ago

dossiers oublies
File size: 13.2 KB
Line 
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-02-ref-02 $
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
47G4tgrVolumeMgr* G4tgrVolumeMgr::theInstance = 0;
48
49
50//-------------------------------------------------------------
51G4tgrVolumeMgr::G4tgrVolumeMgr()
52{
53}
54
55
56//-------------------------------------------------------------
57G4tgrVolumeMgr::~G4tgrVolumeMgr()
58{ 
59  delete theInstance;
60}
61
62
63//-------------------------------------------------------------
64G4tgrVolumeMgr* G4tgrVolumeMgr::GetInstance()
65{
66  if( !theInstance )
67  {
68    theInstance = new G4tgrVolumeMgr;
69  }
70  return theInstance;
71}
72
73
74//-------------------------------------------------------------------
75G4tgrSolid*
76G4tgrVolumeMgr::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//-------------------------------------------------------------------
110void 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//-------------------------------------------------------------
124void 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//-------------------------------------------------------------
141void 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//-------------------------------------------------------------
156void 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
180void G4tgrVolumeMgr::RegisterParentChild( const G4String& parentName,
181                                          const G4tgrPlace* pl )
182{ 
183  theG4tgrVolumeTree.insert(G4mmapspl::value_type(parentName, pl) );
184}
185
186
187//-------------------------------------------------------------
188G4tgrSolid* 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//-------------------------------------------------------------
217G4tgrVolume*
218G4tgrVolumeMgr::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//-------------------------------------------------------------
252std::vector<G4tgrVolume*>
253G4tgrVolumeMgr::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//-------------------------------------------------------------
293const 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//-------------------------------------------------------------
342std::pair<G4mmapspl::iterator, G4mmapspl::iterator>
343G4tgrVolumeMgr::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//-------------------------------------------------------------
352void 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//-------------------------------------------------------------
363void 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//-------------------------------------------------------------
393void 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}
Note: See TracBrowser for help on using the repository browser.