G4GeometryManager Class Reference

#include <G4GeometryManager.hh>

Collaboration diagram for G4GeometryManager:

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

Static Public Member Functions
static G4GeometryManager *	GetInstance ()

Protected Member Functions
	G4GeometryManager ()

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)

Private Attributes
G4bool	fIsClosed

Static Private Attributes
static G4ThreadLocal G4GeometryManager *	fgInstance = 0

Detailed Description

Definition at line 55 of file G4GeometryManager.hh.

Constructor & Destructor Documentation

G4GeometryManager()

G4GeometryManager::G4GeometryManager ( )

protected

Definition at line 69 of file G4GeometryManager.cc.

  : fIsClosed(false)
{
}

Here is the caller graph for this function:

Member Function Documentation

BuildOptimisations() [1/2]

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

private

Definition at line 149 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(0);
     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)
       {
         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() );
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildOptimisations() [2/2]

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

private

Definition at line 225 of file G4GeometryManager.cc.

{
   if (!pVolume) { return; }

   // Retrieve the mother logical volume, if not NULL,
   // otherwise apply global optimisation for the world volume
   //
   G4LogicalVolume* tVolume = pVolume->GetMotherLogical();
   if (!tVolume) { return BuildOptimisations(allOpts, false); }

   G4SmartVoxelHeader* head = tVolume->GetVoxelHeader();
   delete head;
   tVolume->SetVoxelHeader(0);
   if (    ( (tVolume->IsToOptimise())
          && (tVolume->GetNoDaughters()>=kMinVoxelVolumesLevel1&&allOpts) )
        || ( (tVolume->GetNoDaughters()==1)
          && (tVolume->GetDaughter(0)->IsReplicated()==true) ) ) 
   {
     head = new G4SmartVoxelHeader(tVolume);
     if (head)
     {
       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));
  }
}

Here is the call graph for this function:

CloseGeometry()

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

Definition at line 81 of file G4GeometryManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteOptimisations() [1/2]

void G4GeometryManager::DeleteOptimisations ( )

private

Definition at line 283 of file G4GeometryManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteOptimisations() [2/2]

void G4GeometryManager::DeleteOptimisations ( G4VPhysicalVolume *  vol )

private

Definition at line 300 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) { return DeleteOptimisations(); }
  delete tVolume->GetVoxelHeader();
  tVolume->SetVoxelHeader(0);

  // Scan recursively the associated logical volume tree
  //
  tVolume = pVolume->GetLogicalVolume();
  if (tVolume->GetNoDaughters())
  {
    DeleteOptimisations(tVolume->GetDaughter(0));
  }
}

Here is the call graph for this function:

GetInstance()

G4GeometryManager * G4GeometryManager::GetInstance ( void  )

static

Definition at line 135 of file G4GeometryManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

IsGeometryClosed()

G4bool G4GeometryManager::IsGeometryClosed

(

)

Definition at line 125 of file G4GeometryManager.cc.

{
  return fIsClosed;
}

Here is the caller graph for this function:

OpenGeometry()

void G4GeometryManager::OpenGeometry

(

G4VPhysicalVolume *

vol = 0

)

Definition at line 105 of file G4GeometryManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ReportVoxelStats()

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

staticprivate

Definition at line 345 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(), G4SmartVoxelStat::ByCpu() );
         
  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(), G4SmartVoxelStat::ByMemory() );
 
  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;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetWorldMaximumExtent()

void G4GeometryManager::SetWorldMaximumExtent

(

G4double

worldExtent

)

Definition at line 326 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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

fgInstance

G4ThreadLocal G4GeometryManager * G4GeometryManager::fgInstance = 0

staticprivate

Definition at line 92 of file G4GeometryManager.hh.

fIsClosed

G4bool G4GeometryManager::fIsClosed

private

Definition at line 93 of file G4GeometryManager.hh.

---

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

• G4GeometryManager.hh
• G4GeometryManager.cc