#include <G4tgbVolumeMgr.hh>

Public Member Functions
	G4tgbVolumeMgr ()

	~G4tgbVolumeMgr ()

void	AddTextFile (const G4String &fname)

G4VPhysicalVolume *	ReadAndConstructDetector ()

void	CopyVolumes ()

G4tgbVolume *	FindVolume (const G4String &volname)

void	RegisterMe (const G4tgbVolume *vol)

void	RegisterMe (const G4VSolid *solid)

void	RegisterMe (const G4LogicalVolume *lv)

void	RegisterMe (const G4VPhysicalVolume *pv)

void	RegisterChildParentLVs (const G4LogicalVolume logvol, const G4LogicalVolume parentLV)

G4VSolid *	FindG4Solid (const G4String &name)

G4LogicalVolume *	FindG4LogVol (const G4String &theName, const G4bool bExists=0)

G4VPhysicalVolume *	FindG4PhysVol (const G4String &theName, const G4bool bExists=0)

G4VPhysicalVolume *	GetTopPhysVol ()

G4LogicalVolume *	GetTopLogVol ()

void	BuildPhysVolTree ()

void	DumpSummary ()

void	DumpG4LogVolTree ()

void	DumpG4LogVolLeaf (const G4LogicalVolume *lv, unsigned int leafDepth)

void	DumpG4PhysVolTree ()

void	DumpG4PhysVolLeaf (const G4VPhysicalVolume *pv, unsigned int leafDepth)

void	DumpG4SolidList ()

const std::multimap< G4String, G4VSolid * > &	GetSolids () const

void	SetDetectorBuilder (G4tgbDetectorBuilder *db)

G4tgbDetectorBuilder *	GetDetectorBuilder () const

Static Public Member Functions
static G4tgbVolumeMgr *	GetInstance ()

Detailed Description

Definition at line 66 of file G4tgbVolumeMgr.hh.

Constructor & Destructor Documentation

G4tgbVolumeMgr::G4tgbVolumeMgr ( )

Definition at line 56 of file G4tgbVolumeMgr.cc.

References G4ReflectionFactory::Instance(), python.hepunit::mm, and G4ReflectionFactory::SetScalePrecision().

Referenced by GetInstance().

 {
   G4ReflectionFactory::Instance()->SetScalePrecision(1.E-6*mm);
     // NOTE: problems building matrices with not enough figures,
     // like  :ROTM RR30 0.866025 0.5 0. -0.5 0.866025 0. 0. 0 -1
   theDetectorBuilder = new G4tgbDetectorBuilder();
 }

G4tgbVolumeMgr::~G4tgbVolumeMgr ( )

Definition at line 66 of file G4tgbVolumeMgr.cc.

 {
   delete theDetectorBuilder;
   delete theInstance;
 }

Member Function Documentation

void G4tgbVolumeMgr::AddTextFile ( const G4String & fname )

Definition at line 85 of file G4tgbVolumeMgr.cc.

References G4tgrFileReader::AddTextFile(), and G4tgrFileReader::GetInstance().

Referenced by ExTGDetectorConstruction::Construct(), ExTGDetectorConstructionWithSD::Construct(), ExTGDetectorConstructionWithCuts::Construct(), and ExTGDetectorConstructionWithCpp::Construct().

 {
   G4tgrFileReader::GetInstance()->AddTextFile( fname );
 }

void G4tgbVolumeMgr::BuildPhysVolTree ( )

Definition at line 343 of file G4tgbVolumeMgr.cc.

 {
 /*
   G4PhysicalVolumeStore* pvs = G4PhysicalVolumeStore::GetInstance();
   std::vector<G4VPhysicalVolume*>::iterator cite;
   for( cite = pvs->begin(); cite != pvs->end(); cite++ )
   {
     thePVTree[ *cite ] = (*cite)->GetMother();
     thePVInvTree[ (*cite)->GetMother() ] = *cite;
   }
 */
 }

void G4tgbVolumeMgr::CopyVolumes ( )

Definition at line 149 of file G4tgbVolumeMgr.cc.

References G4tgrVolumeMgr::GetInstance(), G4tgrVolumeMgr::GetVolumeMap(), and RegisterMe().

Referenced by G4tgbDetectorConstruction::Construct(), and G4tgbDetectorBuilder::ConstructDetector().

 {
   //--------- Loop G4tgbVolume's and create a G4tgbVolume for each DetUnit
   G4mapsvol::iterator cite;
   G4mapsvol vollist = G4tgrVolumeMgr::GetInstance()->GetVolumeMap();
   for(cite = vollist.begin(); cite != vollist.end(); cite++)
   {
     G4tgrVolume* tgrvol = const_cast<G4tgrVolume*>( (*cite).second );
     G4tgbVolume* svol = new G4tgbVolume( tgrvol );
     RegisterMe( svol );
   }
 }

void G4tgbVolumeMgr::DumpG4LogVolLeaf	(	const G4LogicalVolume *	lv,
		unsigned int	leafDepth
	)

Definition at line 411 of file G4tgbVolumeMgr.cc.

References G4cout, G4endl, and G4LogicalVolume::GetName().

Referenced by DumpG4LogVolTree().

 {
   for( size_t ii=0; ii < leafDepth; ii++ )
   {
     G4cout << "  ";
   }
   G4cout << " LV:(" << leafDepth << ")" << lv->GetName() << G4endl;
   
   //---------- construct the children of this volume
   // G4LogicalVolume* lvnc = const_cast<G4LogicalVolume*>(lv);
   // std::pair<G4mlvlv::iterator, G4mlvlv::iterator> children
   //   = theLVTree.equal_range( lvnc );
   //
   // G4mlvlv::iterator cite; 
   
   leafDepth++;
   // for( cite = children.first; cite != children.second; cite++ )
   // {
   //  DumpG4LVLeaf( (*cite)->second, leafDepth );
   // } 
 }

void G4tgbVolumeMgr::DumpG4LogVolTree ( )

Definition at line 400 of file G4tgbVolumeMgr.cc.

References DumpG4LogVolLeaf(), G4cout, G4endl, and GetTopLogVol().

Referenced by DumpSummary().

 {
   G4cout << " @@@@@@@@@@@@@ DUMPING G4LogicalVolume's Tree  " << G4endl;
   
   G4LogicalVolume* lv = GetTopLogVol();
   
   DumpG4LogVolLeaf(lv, 0);
 }

void G4tgbVolumeMgr::DumpG4PhysVolLeaf	(	const G4VPhysicalVolume *	pv,
		unsigned int	leafDepth
	)

Definition at line 448 of file G4tgbVolumeMgr.cc.

References G4cout, G4endl, and G4VPhysicalVolume::GetName().

Referenced by DumpG4PhysVolTree().

 {
   for( size_t ii=0; ii < leafDepth; ii++ )
   {
     G4cout << "  ";
   }
   G4cout << " PV:(" << leafDepth << ")" << pv->GetName() << G4endl;
 
   //---------- construct the children of this PV
   // G4VPhysicalVolume* pvnc = const_cast<G4VPhysicalVolume*>(pv);
   // std::pair<G4mpvpv::iterator, G4mpvpv::iterator> children
   //  = thePVTree.equal_range( pvnc );
   //
   // G4mpvpv::iterator cite; 
 
   leafDepth++;
   // for( cite = children.first; cite != children.second; cite++ )
   // {
   //  DumpG4PVLeaf( (*cite)->second, leafDepth );
   // }
 }

void G4tgbVolumeMgr::DumpG4PhysVolTree ( )

Definition at line 437 of file G4tgbVolumeMgr.cc.

References DumpG4PhysVolLeaf(), G4cout, G4endl, and GetTopPhysVol().

Referenced by DumpSummary().

 {
   G4cout << " @@@@@@@@@@@@@ DUMPING G4PhysicalVolume's Tree  " << G4endl;
 
   G4VPhysicalVolume* pv = GetTopPhysVol();
 
   DumpG4PhysVolLeaf(pv, 0);
 }

void G4tgbVolumeMgr::DumpG4SolidList ( )

Definition at line 388 of file G4tgbVolumeMgr.cc.

References G4cout, and G4endl.

Referenced by DumpSummary().

 {
   G4mmssol::const_iterator cite;
   for( cite = theSolids.begin(); cite != theSolids.end(); cite++)
   {
     G4cout << "G4SOLID: " << (*cite).second->GetName()
            << " of type " << (*cite).second->GetEntityType() << G4endl;
   }
 } 

void G4tgbVolumeMgr::DumpSummary ( )

Definition at line 358 of file G4tgbVolumeMgr.cc.

References DumpG4LogVolTree(), DumpG4PhysVolTree(), DumpG4SolidList(), G4cout, G4endl, G4tgbMaterialMgr::GetG4ElementList(), G4tgbMaterialMgr::GetG4IsotopeList(), G4tgbMaterialMgr::GetG4MaterialList(), G4tgbRotationMatrixMgr::GetG4RotMatList(), G4tgbRotationMatrixMgr::GetInstance(), G4tgbMaterialMgr::GetInstance(), G4VPhysicalVolume::GetName(), and GetTopPhysVol().

 {
   //---------- Dump number of objects of each class
   G4cout << " @@@@@@@@@@@@@ Dumping Geant4 geometry objects Summary " << G4endl;
   G4cout << " @@@ Geometry built inside world volume: "
          << GetTopPhysVol()->GetName() << G4endl;
   G4cout << " Number of G4VSolid's: " << theSolids.size() << G4endl;
   G4cout << " Number of G4LogicalVolume's: " << theLVs.size() << G4endl;
   G4cout << " Number of G4VPhysicalVolume's: " << thePVs.size() << G4endl;
 
   G4tgbMaterialMgr* mateMgr = G4tgbMaterialMgr::GetInstance();
   G4cout << " Number of G4Isotope's: "
          << mateMgr->GetG4IsotopeList().size() << G4endl;
   G4cout << " Number of G4Element's: "
          << mateMgr->GetG4ElementList().size() << G4endl;
   G4cout << " Number of G4Material's: "
          << mateMgr->GetG4MaterialList().size() << G4endl;
 
   G4tgbRotationMatrixMgr* rotmMgr = G4tgbRotationMatrixMgr::GetInstance();
   G4cout << " Number of G4RotationMatrix's: "
          << rotmMgr->GetG4RotMatList().size() << G4endl;
 
   //---------- Dump list of objects of each class
   DumpG4SolidList();
   DumpG4LogVolTree();
   DumpG4PhysVolTree();
 }

G4LogicalVolume * G4tgbVolumeMgr::FindG4LogVol	(	const G4String &	theName,
		const G4bool	bExists = `0`
	)

Definition at line 239 of file G4tgbVolumeMgr.cc.

References FatalException, and G4Exception().

Referenced by ExTGRCRegionCutsMgr::BuildRegions(), ExTGDetectorConstructionWithCpp::Construct(), G4tgbVolume::ConstructG4PhysVol(), G4tgbVolume::ConstructG4Volumes(), and ExTGDetectorConstructionWithSD::ConstructSDandField().

 {
   G4mmslv::const_iterator mscite = theLVs.find( name );
   if( mscite == theLVs.end() )
   {
     if( exists )
     {
       G4String ErrMessage = "Logical volume name " + name + " not found !";
       G4Exception("G4tgbVolumeMgr::FindG4LogVol()", "InvalidSetup",
                   FatalException, ErrMessage);
     }
     return 0;
   }
   else
   {
     return (*mscite).second;
   }
 }

G4VPhysicalVolume * G4tgbVolumeMgr::FindG4PhysVol	(	const G4String &	theName,
		const G4bool	bExists = `0`
	)

Definition at line 260 of file G4tgbVolumeMgr.cc.

References FatalException, and G4Exception().

 {
   G4mmspv::const_iterator mscite = thePVs.find( name );
   if( mscite == thePVs.end() )
   {
     if( exists )
     {
       G4String ErrMessage = "Physical volume name " + name + " not found !";
       G4Exception("G4tgbVolumeMgr::FindG4PhysVol()", "InvalidSetup",
                   FatalException, ErrMessage);
     }
     return 0;
   }
   else
   {
     return (*mscite).second;
   }
 }

G4VSolid * G4tgbVolumeMgr::FindG4Solid ( const G4String & name )

Definition at line 178 of file G4tgbVolumeMgr.cc.

References G4cout, G4endl, and G4tgrMessenger::GetVerboseLevel().

Referenced by G4tgbVolume::FindOrConstructG4Solid().

 {
 #ifdef G4VERBOSE
   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
   {
     G4cout << " G4tgbVolumeMgr::FindG4Solid() - " << name << G4endl;
   }
 #endif
 
   G4VSolid* oldSolid = 0;
   std::pair<G4mmssol::iterator, G4mmssol::iterator> mmssdi;
   mmssdi = theSolids.equal_range( name );
 
   if( mmssdi.first != mmssdi.second ) { // check there is a solid found
     G4mmssol::const_iterator mmsscite = mmssdi.first;
 
 #ifdef G4VERBOSE
     if( G4tgrMessenger::GetVerboseLevel() >= 2 )
     {
       G4cout << " G4tgbVolumeMgr::FindG4Solid() - Solid finding "
          << name << G4endl; 
     }
 #endif
     /*
        G4VSolid overwrites the operator== comparing the addresses
        => this cannot be used !!
        Then just compare solids by name =>> POSP tag cannot be used
        for the moment ...
          if( solid == *( (*mmsscite).second ) )
          {
            oldSolid = (*mmsscite).second;
            break;
          }
        until we write operator== for each solid type, we take a solid
        with the same name (therefore we will not allow two solids with
        equal name and different parameters (POSP) )
     */
     oldSolid = (*mmsscite).second;
 #ifdef G4VERBOSE
     if( G4tgrMessenger::GetVerboseLevel() >= 1 )
     {
       G4cout << " G4tgbVolumeMgr::FindG4Solid() - Solid already found "
          << name << G4endl; 
     }
 #endif
   }
  
 #ifdef G4VERBOSE
   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
   {
       G4cout << " G4tgbVolumeMgr::FindG4Solid() - Old solid: "
          << oldSolid << G4endl;
   }
 #endif
 
   return oldSolid;
 }

G4tgbVolume * G4tgbVolumeMgr::FindVolume ( const G4String & volname )

Definition at line 164 of file G4tgbVolumeMgr.cc.

References FatalException, and G4Exception().

Referenced by G4tgbDetectorConstruction::Construct(), G4tgbDetectorBuilder::ConstructDetector(), G4tgbVolume::ConstructG4PhysVol(), and G4tgbVolume::ConstructG4Volumes().

 {
   G4mssvol::const_iterator cite = theVolumeList.find( volname );
   if( cite == theVolumeList.end() )
   {
     G4String ErrMessage = "G4tgbVolume not found: " + volname + " !";
     G4Exception("G4tgbVolumeMgr::FindVolume()", "InvalidSetup",
                 FatalException, ErrMessage);
   }
   return (*cite).second;
 }

G4tgbDetectorBuilder* G4tgbVolumeMgr::GetDetectorBuilder ( ) const

inline

Definition at line 135 of file G4tgbVolumeMgr.hh.

136 { return theDetectorBuilder; }

G4tgbVolumeMgr * G4tgbVolumeMgr::GetInstance ( void )

static

Definition at line 74 of file G4tgbVolumeMgr.cc.

References G4tgbVolumeMgr().

Referenced by ExTGRCRegionCutsMgr::BuildRegions(), ExTGDetectorConstructionWithCpp::Construct(), ExTGDetectorConstructionWithSD::Construct(), ExTGDetectorConstruction::Construct(), ExTGDetectorConstructionWithCuts::Construct(), G4tgbDetectorConstruction::Construct(), G4tgbDetectorBuilder::ConstructDetector(), G4tgbVolume::ConstructG4PhysVol(), G4tgbVolume::ConstructG4Volumes(), ExTGDetectorConstructionWithSD::ConstructSDandField(), and G4tgbVolume::FindOrConstructG4Solid().

 {
   if( !theInstance )
   {
     theInstance = new G4tgbVolumeMgr();
   }
   return theInstance;
 }

const std::multimap< G4String, G4VSolid* >& G4tgbVolumeMgr::GetSolids ( ) const

inline

Definition at line 131 of file G4tgbVolumeMgr.hh.

132 { return theSolids; }

G4LogicalVolume * G4tgbVolumeMgr::GetTopLogVol ( )

Definition at line 299 of file G4tgbVolumeMgr.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4LogicalVolume::GetName(), and G4tgrMessenger::GetVerboseLevel().

Referenced by DumpG4LogVolTree(), and GetTopPhysVol().

 {
   //----------- Start from any G4LogicalVolume, because if you go upwards
   //            you will always end at the top  
 #ifdef G4VERBOSE
   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
   {
     G4cout << " G4tgbVolumeMgr::GetTopLogVol theLVInvTresize "
            << theLVInvTree.size() << G4endl;
   }
 #endif
   if(  theLVInvTree.size() == 0 ) 
   { 
     G4Exception("G4tgbVolumeMgr::GetTopLogVol()", "InvalidSetup",
                 FatalException, "theLVInvTree has no elements.");
   }
   G4LogicalVolume* lv = (*(theLVInvTree.begin())).second;
 
   //------- if first element is the top LV, its parent is 0
   if( lv == 0 ) 
   {
     lv = (*(theLVInvTree.begin())).first;
   } 
   else 
   {
     while( (*(theLVInvTree.find( lv ))).second != 0) 
     {
       //---------- get parent of first position
       lv = (*(theLVInvTree.find( lv ))).second;
 #ifdef G4VERBOSE
       if( G4tgrMessenger::GetVerboseLevel() >= 2 )
       {
         G4cout << " G4tgbVolumeMgr::GetTopPhysVol: lv "
                << lv->GetName() << G4endl;
       }
 #endif
     }
   }
   
   return lv;
 }

G4VPhysicalVolume * G4tgbVolumeMgr::GetTopPhysVol ( )

Definition at line 281 of file G4tgbVolumeMgr.cc.

References G4cout, G4endl, G4VPhysicalVolume::GetName(), G4LogicalVolume::GetName(), GetTopLogVol(), G4tgrMessenger::GetVerboseLevel(), and python.hepunit::second.

Referenced by G4tgbDetectorBuilder::ConstructDetector(), DumpG4PhysVolTree(), and DumpSummary().

 {
   G4LogicalVolume* lv = GetTopLogVol(); 
   G4VPhysicalVolume* pv = ( *(thePVs.find( lv->GetName() )) ).second;
 
 #ifdef G4VERBOSE
   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
   {
     G4cout << " G4tgbVolumeMgr::GetTopPhysVol() - pv: "
            << pv->GetName() << G4endl;
   }
 #endif
 
   return pv;
 }

G4VPhysicalVolume * G4tgbVolumeMgr::ReadAndConstructDetector ( )

Definition at line 92 of file G4tgbVolumeMgr.cc.

References G4tgbDetectorBuilder::ConstructDetector(), and G4tgbDetectorBuilder::ReadDetector().

Referenced by ExTGDetectorConstruction::Construct(), ExTGDetectorConstructionWithSD::Construct(), and ExTGDetectorConstructionWithCpp::Construct().

 {
   const G4tgrVolume* tgrVoltop = theDetectorBuilder->ReadDetector();
   return theDetectorBuilder->ConstructDetector(tgrVoltop);
 }

void G4tgbVolumeMgr::RegisterChildParentLVs	(	const G4LogicalVolume *	logvol,
		const G4LogicalVolume *	parentLV
	)

Definition at line 139 of file G4tgbVolumeMgr.cc.

Referenced by G4tgbVolume::ConstructG4Volumes().

 {
   theLVInvTree[const_cast<G4LogicalVolume*>(logvol)] =
     const_cast<G4LogicalVolume*>(parentLV);
   theLVTree[const_cast<G4LogicalVolume*>(parentLV)] =
     const_cast<G4LogicalVolume*>(logvol);
 }

void G4tgbVolumeMgr::RegisterMe ( const G4tgbVolume * vol )

Definition at line 100 of file G4tgbVolumeMgr.cc.

References G4tgbVolume::GetName().

Referenced by G4tgbVolume::ConstructG4Volumes(), and CopyVolumes().

 {
   theVolumeList.insert( G4mssvol::value_type( vol->GetName(),
                         const_cast<G4tgbVolume*>(vol) ) );
 }

void G4tgbVolumeMgr::RegisterMe ( const G4VSolid * solid )

Definition at line 108 of file G4tgbVolumeMgr.cc.

References G4VSolid::GetName().

 {
   theSolids.insert( G4mmssol::value_type( solid->GetName(),
                     const_cast<G4VSolid*>(solid) ) );
 }

void G4tgbVolumeMgr::RegisterMe ( const G4LogicalVolume * lv )

Definition at line 116 of file G4tgbVolumeMgr.cc.

References G4cout, G4endl, G4LogicalVolume::GetName(), and G4tgrMessenger::GetVerboseLevel().

 {
   theLVs.insert( G4mmslv::value_type( lv->GetName(),
                  const_cast<G4LogicalVolume*>(lv) ) );
 
 #ifdef G4VERBOSE
   if( G4tgrMessenger::GetVerboseLevel() >= 2 )
   {
     G4cout << " G4tgbVolumeMgr::RegisterMe() - Logical volume registered: "
            << lv->GetName() << G4endl; 
   }
 #endif
 }

void G4tgbVolumeMgr::RegisterMe ( const G4VPhysicalVolume * pv )

Definition at line 131 of file G4tgbVolumeMgr.cc.

References G4VPhysicalVolume::GetName().

 {
   thePVs.insert( G4mmspv::value_type( pv->GetName(),
                  const_cast<G4VPhysicalVolume*>(pv) ) );
 }

void G4tgbVolumeMgr::SetDetectorBuilder ( G4tgbDetectorBuilder * db )

inline

Definition at line 133 of file G4tgbVolumeMgr.hh.

Referenced by ExTGDetectorConstructionWithCuts::Construct().

134 { theDetectorBuilder = db; }

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation