G4GeometryManager Class Reference

#include <G4GeometryManager.hh>

Public Member Functions
G4bool	CloseGeometry (G4bool pOptimise=true, G4bool verbose=false, G4VPhysicalVolume *vol=nullptr)
void	OpenGeometry (G4VPhysicalVolume *vol=nullptr)
void	SetWorldMaximumExtent (G4double worldExtent)
	~G4GeometryManager ()

Static Public Member Functions
static G4GeometryManager *	GetInstance ()
static G4GeometryManager *	GetInstanceIfExist ()
static G4bool	IsGeometryClosed ()

Protected Member Functions
	G4GeometryManager ()=default

Private Member Functions
void	BuildOptimisations (G4bool allOpt, G4bool verbose=false)
void	BuildOptimisations (G4bool allOpt, G4VPhysicalVolume *vol)
void	DeleteOptimisations ()
void	DeleteOptimisations (G4VPhysicalVolume *vol)

Static Private Member Functions
static void	ReportVoxelStats (std::vector< G4SmartVoxelStat > &stats, G4double totalCpuTime)

Static Private Attributes
static G4ThreadLocal G4GeometryManager *	fgInstance = nullptr
static G4ThreadLocal G4bool	fIsClosed = false

Detailed Description

Definition at line 52 of file G4GeometryManager.hh.

Constructor & Destructor Documentation

~G4GeometryManager()

G4GeometryManager::~G4GeometryManager

(

)

Definition at line 65 of file G4GeometryManager.cc.

{
  fgInstance = nullptr;
  fIsClosed = false;
}

References fgInstance, and fIsClosed.

G4GeometryManager()

G4GeometryManager::G4GeometryManager ( )

protecteddefault

Referenced by GetInstance().

Member Function Documentation

BuildOptimisations() [1/2]

void G4GeometryManager::BuildOptimisations ( G4bool  allOpt, G4bool  verbose = false  )

private

Definition at line 155 of file G4GeometryManager.cc.

{
   G4Timer timer;
   G4Timer allTimer;
   std::vector<G4SmartVoxelStat> stats;
   if (verbose)  { allTimer.Start(); }
 
   G4LogicalVolumeStore* Store = G4LogicalVolumeStore::GetInstance();
   G4LogicalVolume* volume;
   G4SmartVoxelHeader* head;
 
   for (size_t n=0; n<Store->size(); ++n)
   {
     if (verbose) timer.Start();
     volume=(*Store)[n];
     // For safety, check if there are any existing voxels and
     // delete before replacement
     //
     head = volume->GetVoxelHeader();
     delete head;
     volume->SetVoxelHeader(nullptr);
     if (    ( (volume->IsToOptimise())
            && (volume->GetNoDaughters()>=kMinVoxelVolumesLevel1&&allOpts) )
          || ( (volume->GetNoDaughters()==1)
            && (volume->GetDaughter(0)->IsReplicated()==true)
            && (volume->GetDaughter(0)->GetRegularStructureId()!=1) ) ) 
     {
#ifdef G4GEOMETRY_VOXELDEBUG
       G4cout << "**** G4GeometryManager::BuildOptimisations" << G4endl
              << "     Examining logical volume name = "
              << volume->GetName() << G4endl;
#endif
       head = new G4SmartVoxelHeader(volume);
       if (head != nullptr)
       {
         volume->SetVoxelHeader(head);
       }
       else
       {
         std::ostringstream message;
         message << "VoxelHeader allocation error." << G4endl
                 << "Allocation of new VoxelHeader" << G4endl
                 << "        for volume " << volume->GetName() << " failed.";
         G4Exception("G4GeometryManager::BuildOptimisations()", "GeomMgt0003",
                     FatalException, message);
       }
       if (verbose)
       {
         timer.Stop();
         stats.push_back( G4SmartVoxelStat( volume, head,
                                            timer.GetSystemElapsed(),
                                            timer.GetUserElapsed() ) );
       }
     }
     else
     {
       // Don't create voxels for this node
#ifdef G4GEOMETRY_VOXELDEBUG
       G4cout << "**** G4GeometryManager::BuildOptimisations" << G4endl
              << "     Skipping logical volume name = " << volume->GetName()
              << G4endl;
#endif
     }
  }
  if (verbose)
  {
     allTimer.Stop();
     ReportVoxelStats( stats, allTimer.GetSystemElapsed()
                            + allTimer.GetUserElapsed() );
  }
}

References FatalException, G4cout, G4endl, G4Exception(), G4LogicalVolume::GetDaughter(), G4LogicalVolumeStore::GetInstance(), G4LogicalVolume::GetName(), G4LogicalVolume::GetNoDaughters(), G4VPhysicalVolume::GetRegularStructureId(), G4Timer::GetSystemElapsed(), G4Timer::GetUserElapsed(), G4LogicalVolume::GetVoxelHeader(), G4VPhysicalVolume::IsReplicated(), G4LogicalVolume::IsToOptimise(), kMinVoxelVolumesLevel1, CLHEP::detail::n, ReportVoxelStats(), G4LogicalVolume::SetVoxelHeader(), G4Timer::Start(), and G4Timer::Stop().

Referenced by BuildOptimisations(), and CloseGeometry().

BuildOptimisations() [2/2]

void G4GeometryManager::BuildOptimisations ( G4bool  allOpt, G4VPhysicalVolume *  vol  )

private

Definition at line 231 of file G4GeometryManager.cc.

{
   if (pVolume == nullptr) { return; }
 
   // Retrieve the mother logical volume, if not NULL,
   // otherwise apply global optimisation for the world volume
   //
   G4LogicalVolume* tVolume = pVolume->GetMotherLogical();
   if (tVolume == nullptr) { return BuildOptimisations(allOpts, false); }
 
   G4SmartVoxelHeader* head = tVolume->GetVoxelHeader();
   delete head;
   tVolume->SetVoxelHeader(nullptr);
   if (    ( (tVolume->IsToOptimise())
          && (tVolume->GetNoDaughters()>=kMinVoxelVolumesLevel1&&allOpts) )
        || ( (tVolume->GetNoDaughters()==1)
          && (tVolume->GetDaughter(0)->IsReplicated()==true) ) ) 
   {
     head = new G4SmartVoxelHeader(tVolume);
     if (head != nullptr)
     {
       tVolume->SetVoxelHeader(head);
     }
     else
     {
       std::ostringstream message;
       message << "VoxelHeader allocation error." << G4endl
               << "Allocation of new VoxelHeader" << G4endl
               << "        for volume " << tVolume->GetName() << " failed.";
       G4Exception("G4GeometryManager::BuildOptimisations()", "GeomMgt0003",
                   FatalException, message);
     }
   }
   else
   {
     // Don't create voxels for this node
#ifdef G4GEOMETRY_VOXELDEBUG
     G4cout << "**** G4GeometryManager::BuildOptimisations" << G4endl
            << "     Skipping logical volume name = " << tVolume->GetName()
            << G4endl;
#endif
   }
 
   // Scan recursively the associated logical volume tree
   //
  tVolume = pVolume->GetLogicalVolume();
  if (tVolume->GetNoDaughters())
  {
    BuildOptimisations(allOpts, tVolume->GetDaughter(0));
  }
}

References BuildOptimisations(), FatalException, G4cout, G4endl, G4Exception(), G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMotherLogical(), G4LogicalVolume::GetName(), G4LogicalVolume::GetNoDaughters(), G4LogicalVolume::GetVoxelHeader(), G4VPhysicalVolume::IsReplicated(), G4LogicalVolume::IsToOptimise(), kMinVoxelVolumesLevel1, and G4LogicalVolume::SetVoxelHeader().

CloseGeometry()

G4bool G4GeometryManager::CloseGeometry	(	G4bool	pOptimise = true,
		G4bool	verbose = false,
		G4VPhysicalVolume *	vol = nullptr
	)

Definition at line 78 of file G4GeometryManager.cc.

{
  if (!fIsClosed)
  {
    if (pVolume != nullptr)
    {
      BuildOptimisations(pOptimise, pVolume);
    }
    else
    {
      BuildOptimisations(pOptimise, verbose);
    }
    fIsClosed = true;
  }
  return true;
}

References BuildOptimisations(), and fIsClosed.

Referenced by G4GeometryMessenger::CheckGeometry(), G4TheRayTracer::CreateBitMap(), G4MaterialScanner::DoScan(), export_G4GeometryManager(), G4DNAChemistryManager::HandleStandaloneInitialization(), G4RunManagerKernel::ResetNavigator(), G4MaterialScanner::StoreUserActions(), and G4TheRayTracer::StoreUserActions().

DeleteOptimisations() [1/2]

void G4GeometryManager::DeleteOptimisations ( )

private

Definition at line 289 of file G4GeometryManager.cc.

{
  G4LogicalVolume* tVolume = nullptr;
  G4LogicalVolumeStore* Store = G4LogicalVolumeStore::GetInstance();
  for (size_t n=0; n<Store->size(); ++n)
  {
    tVolume=(*Store)[n];
    delete tVolume->GetVoxelHeader();
    tVolume->SetVoxelHeader(nullptr);
  }
}

References G4LogicalVolumeStore::GetInstance(), G4LogicalVolume::GetVoxelHeader(), CLHEP::detail::n, and G4LogicalVolume::SetVoxelHeader().

Referenced by DeleteOptimisations(), and OpenGeometry().

DeleteOptimisations() [2/2]

void G4GeometryManager::DeleteOptimisations ( G4VPhysicalVolume *  vol )

private

Definition at line 306 of file G4GeometryManager.cc.

{
  if (!pVolume) { return; }
 
  // Retrieve the mother logical volume, if not NULL,
  // otherwise global deletion to world volume.
  //
  G4LogicalVolume* tVolume = pVolume->GetMotherLogical();
  if (tVolume == nullptr) { return DeleteOptimisations(); }
  delete tVolume->GetVoxelHeader();
  tVolume->SetVoxelHeader(nullptr);
 
  // Scan recursively the associated logical volume tree
  //
  tVolume = pVolume->GetLogicalVolume();
  if (tVolume->GetNoDaughters())
  {
    DeleteOptimisations(tVolume->GetDaughter(0));
  }
}

References DeleteOptimisations(), G4LogicalVolume::GetDaughter(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMotherLogical(), G4LogicalVolume::GetNoDaughters(), G4LogicalVolume::GetVoxelHeader(), and G4LogicalVolume::SetVoxelHeader().

GetInstance()

G4GeometryManager * G4GeometryManager::GetInstance ( )

static

Definition at line 132 of file G4GeometryManager.cc.

{
  if (fgInstance == nullptr)
  {
    fgInstance = new G4GeometryManager;
  }
  return fgInstance;
}

References fgInstance, and G4GeometryManager().

Referenced by G4GeometryMessenger::CheckGeometry(), G4ErrorPropagatorManager::CloseGeometry(), ExN03DetectorConstruction::ConstructCalorimeter(), DetectorConstruction::ConstructVolumes(), G4TheRayTracer::CreateBitMap(), G4MaterialScanner::DoScan(), export_G4GeometryManager(), G4DNAChemistryManager::HandleStandaloneInitialization(), G4RunManager::ReinitializeGeometry(), G4RunManagerKernel::ResetNavigator(), G4GDMLMessenger::SetNewValue(), G4MaterialScanner::StoreUserActions(), G4TheRayTracer::StoreUserActions(), and G4RunManagerKernel::~G4RunManagerKernel().

GetInstanceIfExist()

G4GeometryManager * G4GeometryManager::GetInstanceIfExist ( )

static

Definition at line 145 of file G4GeometryManager.cc.

{
  return fgInstance;
}

References fgInstance.

Referenced by G4RunManagerKernel::~G4RunManagerKernel().

IsGeometryClosed()

G4bool G4GeometryManager::IsGeometryClosed ( )

static

Definition at line 122 of file G4GeometryManager.cc.

{
  return fIsClosed;
}

References fIsClosed.

Referenced by G4GeometryMessenger::CheckGeometry(), G4LogicalVolumeStore::Clean(), G4PhysicalVolumeStore::Clean(), G4RegionStore::Clean(), G4SolidStore::Clean(), G4AssemblyStore::Clean(), and export_G4GeometryManager().

OpenGeometry()

void G4GeometryManager::OpenGeometry

(

G4VPhysicalVolume *

vol = nullptr

)

Definition at line 102 of file G4GeometryManager.cc.

{
  if (fIsClosed)
  {
    if (pVolume != nullptr)
    {
      DeleteOptimisations(pVolume);
    }
    else
    {
      DeleteOptimisations();
    }
    fIsClosed = false;
  }
}

References DeleteOptimisations(), and fIsClosed.

Referenced by G4GeometryMessenger::CheckGeometry(), G4ErrorPropagatorManager::CloseGeometry(), ExN03DetectorConstruction::ConstructCalorimeter(), DetectorConstruction::ConstructVolumes(), G4TheRayTracer::CreateBitMap(), G4MaterialScanner::DoScan(), export_G4GeometryManager(), G4DNAChemistryManager::HandleStandaloneInitialization(), G4RunManager::ReinitializeGeometry(), G4RunManagerKernel::ResetNavigator(), G4GDMLMessenger::SetNewValue(), G4MaterialScanner::StoreUserActions(), G4TheRayTracer::StoreUserActions(), and G4RunManagerKernel::~G4RunManagerKernel().

ReportVoxelStats()

void G4GeometryManager::ReportVoxelStats ( std::vector< G4SmartVoxelStat > &  stats, G4double  totalCpuTime  )

staticprivate

Definition at line 351 of file G4GeometryManager.cc.

{
  G4cout << "G4GeometryManager::ReportVoxelStats -- Voxel Statistics"
         << G4endl << G4endl;
 
  //
  // Get total memory use
  //
  G4int i, nStat = stats.size();
  G4long totalMemory = 0;
 
  for( i=0; i<nStat; ++i )  { totalMemory += stats[i].GetMemoryUse(); }
 
  G4cout << "    Total memory consumed for geometry optimisation:   "
         << totalMemory/1024 << " kByte" << G4endl;
  G4cout << "    Total CPU time elapsed for geometry optimisation: " 
         << std::setprecision(2) << totalCpuTime << " seconds"
         << std::setprecision(6) << G4endl;
 
  //
  // First list: sort by total CPU time
  //
  std::sort( stats.begin(), stats.end(),
    [](const G4SmartVoxelStat& a, const G4SmartVoxelStat& b)
  {
    return a.GetTotalTime() > b.GetTotalTime();
  } );
         
  G4int nPrint = nStat > 10 ? 10 : nStat;
 
  if (nPrint)
  {
    G4cout << "\n    Voxelisation: top CPU users:" << G4endl;
    G4cout << "    Percent   Total CPU    System CPU       Memory  Volume\n"
           << "    -------   ----------   ----------     --------  ----------"
           << G4endl;
    //         12345678901.234567890123.234567890123.234567890123k .
  }
 
  for(i=0; i<nPrint; ++i)
  {
    G4double total = stats[i].GetTotalTime();
    G4double system = stats[i].GetSysTime();
    G4double perc = 0.0;
 
    if (system < 0) { system = 0.0; }
    if ((total < 0) || (totalCpuTime < perMillion))
      { total = 0; }
    else
      { perc = total*100/totalCpuTime; }
 
    G4cout << std::setprecision(2) 
           << std::setiosflags(std::ios::fixed|std::ios::right)
           << std::setw(11) << perc
           << std::setw(13) << total
           << std::setw(13) << system
           << std::setw(13) << (stats[i].GetMemoryUse()+512)/1024
           << "k " << std::setiosflags(std::ios::left)
           << stats[i].GetVolume()->GetName()
           << std::resetiosflags(std::ios::floatfield|std::ios::adjustfield)
           << std::setprecision(6)
           << G4endl;
  }
 
  //
  // Second list: sort by memory use
  //
  std::sort( stats.begin(), stats.end(),
    [](const G4SmartVoxelStat& a, const G4SmartVoxelStat& b)
  {
    return a.GetMemoryUse() > b.GetMemoryUse();
  } );
 
  if (nPrint)
  {
    G4cout << "\n    Voxelisation: top memory users:" << G4endl;
    G4cout << "    Percent     Memory      Heads    Nodes   Pointers    Total CPU    Volume\n"
           << "    -------   --------     ------   ------   --------   ----------    ----------"
           << G4endl;
    //         12345678901.2345678901k .23456789.23456789.2345678901.234567890123.   .
  }
 
  for(i=0; i<nPrint; ++i)
  {
    G4long memory = stats[i].GetMemoryUse();
    G4double totTime = stats[i].GetTotalTime();
    if (totTime < 0) { totTime = 0.0; }
 
    G4cout << std::setprecision(2) 
           << std::setiosflags(std::ios::fixed|std::ios::right)
           << std::setw(11) << G4double(memory*100)/G4double(totalMemory)
           << std::setw(11) << memory/1024 << "k "
           << std::setw( 9) << stats[i].GetNumberHeads()
           << std::setw( 9) << stats[i].GetNumberNodes()
           << std::setw(11) << stats[i].GetNumberPointers()
           << std::setw(13) << totTime << "    "
           << std::setiosflags(std::ios::left)
           << stats[i].GetVolume()->GetName()
           << std::resetiosflags(std::ios::floatfield|std::ios::adjustfield)
           << std::setprecision(6)
           << G4endl;
  }
}

References G4cout, G4endl, perMillion, and G4INCL::CrossSections::total().

Referenced by BuildOptimisations().

SetWorldMaximumExtent()

void G4GeometryManager::SetWorldMaximumExtent

(

G4double

worldExtent

)

Definition at line 332 of file G4GeometryManager.cc.

{
  if (G4SolidStore::GetInstance()->size())
  {
     // Sanity check to assure that extent is fixed BEFORE creating
     // any geometry object (solids in this case)
     //
     G4Exception("G4GeometryManager::SetMaximumExtent()",
                 "GeomMgt0003", FatalException,
                 "Extent can be set only BEFORE creating any geometry object!");
  }
  G4GeometryTolerance::GetInstance()->SetSurfaceTolerance(extent);
}

References FatalException, G4Exception(), G4SolidStore::GetInstance(), G4GeometryTolerance::GetInstance(), and G4GeometryTolerance::SetSurfaceTolerance().

Referenced by export_G4GeometryManager().

Field Documentation

fgInstance

G4ThreadLocal G4GeometryManager * G4GeometryManager::fgInstance = nullptr

staticprivate

Definition at line 99 of file G4GeometryManager.hh.

Referenced by GetInstance(), GetInstanceIfExist(), and ~G4GeometryManager().

fIsClosed

G4ThreadLocal G4bool G4GeometryManager::fIsClosed = false

staticprivate

Definition at line 100 of file G4GeometryManager.hh.

Referenced by CloseGeometry(), IsGeometryClosed(), OpenGeometry(), and ~G4GeometryManager().

---

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

• source/geometry/management/include/G4GeometryManager.hh
• source/geometry/management/src/G4GeometryManager.cc