#include <G4GeometryManager.hh>

Public Member Functions
G4bool	CloseGeometry (G4bool pOptimise=true, G4bool verbose=false, G4VPhysicalVolume *vol=nullptr)

void	OpenGeometry (G4VPhysicalVolume *vol=nullptr)

G4bool	IsGeometryClosed ()

void	SetWorldMaximumExtent (G4double worldExtent)

void	OptimiseInParallel (G4bool val=true)

void	UndertakeOptimisation ()

void	RequestParallelOptimisation (G4bool val=true, G4bool verbose=true)

void	ChooseSequentialOptimisation (G4bool verbose=false)

G4bool	IsParallelOptimisationConfigured ()

G4bool	IsParallelOptimisationFinished ()

	~G4GeometryManager ()

Static Public Member Functions
static G4GeometryManager *	GetInstance ()

static G4GeometryManager *	GetInstanceIfExist ()

Detailed Description

Definition at line 55 of file G4GeometryManager.hh.

Constructor & Destructor Documentation

◆ ~G4GeometryManager()

G4GeometryManager::~G4GeometryManager ( )

Definition at line 111 of file G4GeometryManager.cc.

{
  fgInstance = nullptr;
  fIsClosed = false;
  
  if( fWallClockTimer && G4Threading::IsMasterThread() )
  {
    delete fWallClockTimer;
    fWallClockTimer= nullptr;
  }
}

Member Function Documentation

◆ ChooseSequentialOptimisation()

void G4GeometryManager::ChooseSequentialOptimisation ( G4bool verbose = false )

◆ CloseGeometry()

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

Definition at line 130 of file G4GeometryManager.cc.

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

Referenced by G4TheRayTracer::CreateBitMap(), G4DNAChemistryManager::HandleStandaloneInitialization(), G4RunManagerKernel::ResetNavigator(), and G4TheRayTracer::StoreUserActions().

◆ GetInstance()

G4GeometryManager * G4GeometryManager::GetInstance ( )

static

Definition at line 175 of file G4GeometryManager.cc.

{
  if (fgInstance == nullptr)
  {
    fgInstance = new G4GeometryManager;
    
    if( (fWallClockTimer == nullptr) && G4Threading::IsMasterThread() )
    {
      fWallClockTimer = new G4Timer;
    }
  }
  return fgInstance;
}

Referenced by G4AssemblyStore::Clean(), G4LogicalVolumeStore::Clean(), G4PhysicalVolumeStore::Clean(), G4RegionStore::Clean(), G4SolidStore::Clean(), G4ErrorPropagatorManager::CloseGeometry(), G4TheRayTracer::CreateBitMap(), G4DNAChemistryManager::HandleStandaloneInitialization(), G4WorkerRunManager::InitializeGeometry(), G4RunManager::ReinitializeGeometry(), G4RunManagerKernel::ResetNavigator(), G4GDMLMessenger::SetNewValue(), G4TheRayTracer::StoreUserActions(), and G4RunManagerKernel::~G4RunManagerKernel().

◆ GetInstanceIfExist()

G4GeometryManager * G4GeometryManager::GetInstanceIfExist ( )

static

Definition at line 193 of file G4GeometryManager.cc.

{
  return fgInstance;
}

Referenced by G4RunManagerKernel::~G4RunManagerKernel().

◆ IsGeometryClosed()

G4bool G4GeometryManager::IsGeometryClosed ( )

inline

Definition at line 70 of file G4GeometryManager.hh.

70{ return fIsClosed; }

◆ IsParallelOptimisationConfigured()

G4bool G4GeometryManager::IsParallelOptimisationConfigured ( )

Definition at line 974 of file G4GeometryManager.cc.

{
  return fOptimiseInParallelConfigured;
}

Referenced by G4WorkerRunManager::InitializeGeometry(), and G4RunManagerKernel::ResetNavigator().

◆ IsParallelOptimisationFinished()

G4bool G4GeometryManager::IsParallelOptimisationFinished ( )

Definition at line 983 of file G4GeometryManager.cc.

{
  return fParallelVoxelOptimisationFinished;
}

Referenced by G4RunManagerKernel::ResetNavigator(), and UndertakeOptimisation().

◆ OpenGeometry()

void G4GeometryManager::OpenGeometry ( G4VPhysicalVolume * vol = nullptr )

Definition at line 154 of file G4GeometryManager.cc.

{
  if (fIsClosed && G4Threading::IsMasterThread())
  {
    if (pVolume != nullptr)
    {
      DeleteOptimisations(pVolume);
    }
    else
    {
      DeleteOptimisations();
    }
    fIsClosed = false;
  }
}

Referenced by G4ErrorPropagatorManager::CloseGeometry(), G4TheRayTracer::CreateBitMap(), G4DNAChemistryManager::HandleStandaloneInitialization(), G4RunManager::ReinitializeGeometry(), G4RunManagerKernel::ResetNavigator(), G4GDMLMessenger::SetNewValue(), G4TheRayTracer::StoreUserActions(), and G4RunManagerKernel::~G4RunManagerKernel().

◆ OptimiseInParallel()

void G4GeometryManager::OptimiseInParallel ( G4bool val = true )

Definition at line 202 of file G4GeometryManager.cc.

{
  RequestParallelOptimisation(val);
}

◆ RequestParallelOptimisation()

void G4GeometryManager::RequestParallelOptimisation	(	G4bool	val = true,
		G4bool	verbose = true )

Definition at line 470 of file G4GeometryManager.cc.

{
  fParallelVoxelOptimisationRequested = flag;
  if( flag )
  {
    ConfigureParallelOptimisation(verbose);
  }
}

Referenced by OptimiseInParallel().

◆ SetWorldMaximumExtent()

void G4GeometryManager::SetWorldMaximumExtent ( G4double worldExtent )

Definition at line 842 of file G4GeometryManager.cc.

{
  if (!G4SolidStore::GetInstance()->empty())
  {
     // 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);
}

◆ UndertakeOptimisation()

void G4GeometryManager::UndertakeOptimisation ( )

Definition at line 526 of file G4GeometryManager.cc.

{
  G4bool verbose = fVerboseParallel;
  G4LogicalVolume* logVolume = nullptr;
 
  fParallelVoxelOptimisationUnderway  = true;
  
  // Start timer - if not already done
  if( ( !fWallClockStarted ) && verbose )
  {
    G4AutoLock startTimeLock(wallClockTimerMutex);
    if( !fWallClockStarted )
    {
      fWallClockTimer->Start();
      fWallClockStarted= true;
    }
  }
 
  G4Timer fetimer;
  unsigned int numVolumesOptimised = 0;
  
  while( (logVolume = ObtainVolumeToOptimise()) != nullptr )
  {
    if (verbose) fetimer.Start();
 
    G4SmartVoxelHeader* head = logVolume->GetVoxelHeader();
    delete head;
    logVolume->SetVoxelHeader(nullptr);
 
    head = new G4SmartVoxelHeader(logVolume);
    //     *********************************
    logVolume->SetVoxelHeader(head);
    
    if (head != nullptr)
    {
      ++numVolumesOptimised;
    }
    else
    {
      G4ExceptionDescription message;
      message << "VoxelHeader allocation error." << G4endl
              << "Allocation of new VoxelHeader" << G4endl
              << "for logical volume " << logVolume->GetName() << " failed.";
      G4Exception("G4GeometryManager::BuildOptimisationsParallel()",
                  "GeomMgt0003", FatalException, message);
    }
 
    if(verbose)
    {
      fetimer.Stop();
      auto feRealElapsed = fetimer.GetRealElapsed();
      // Must use 'real' elapsed time -- cannot trust user/system time
      // (it accounts for all threads)
      
      G4AutoLock lock(voxelStatsMutex);
      fGlobVoxelStats.emplace_back( logVolume, head,
                          0.0,             // Cannot estimate system time
                          feRealElapsed ); // Use real time instead of user time
      fSumVoxelTime += feRealElapsed;
    }
  }
 
  G4bool allDone = false;
  G4int myCount= -1;
 
  myCount = ReportWorkerIsDoneOptimising(numVolumesOptimised);
  allDone = IsParallelOptimisationFinished();
 
  if( allDone && (myCount == G4Threading::GetNumberOfRunningWorkerThreads()) )
  {
    G4int badVolumes = CheckOptimisation(); // Check all voxels are created!
    if( badVolumes > 0 )
    {
      G4ExceptionDescription errmsg;
      errmsg <<" Expected that all voxelisation work is done, "
             << "but found that voxels headers are missing in "
             << badVolumes << " volumes.";
      G4Exception("G4GeometryManager::UndertakeOptimisation()",
                  "GeomMng002", FatalException, errmsg);
    }
    
    // Create report
 
    if( verbose )
    {
      fWallClockTimer->Stop();
 
      std::ostream& report_stream = std::cout; // G4cout; does not work!
      report_stream << G4endl
        << "G4GeometryManager::UndertakeOptimisation"
        << " -- Timing for Voxel Optimisation" << G4endl;
      report_stream << "  - Elapsed time (real) = " << std::setprecision(4)
        << fWallClockTimer->GetRealElapsed() << "s (wall clock)"
        << ", user " << fWallClockTimer->GetUserElapsed() << "s"
        << ", system " << fWallClockTimer->GetSystemElapsed() << "s."
        << G4endl;
      report_stream << "  - Sum voxel time (real) = " << fSumVoxelTime
                    << "s.";
      report_stream << std::setprecision(6) << G4endl << G4endl;
 
      ReportVoxelStats( fGlobVoxelStats, fSumVoxelTime, report_stream );
      report_stream.flush();
    }
  }
  else
  {
    WaitForVoxelisationFinish(false);
  }
}