G4VoxelisationHelper Class Reference

G4VoxelisationHelper is a helper class to undertake voxelisation in parallel, aiding and off-loading the work of G4GeometryManager. More...

#include <G4VoxelisationHelper.hh>

Public Member Functions
	G4VoxelisationHelper ()
	~G4VoxelisationHelper ()
void	PrepareParallelOptimisation (G4bool allOpts, G4bool verbose)
void	UndertakeOptimisation ()
void	ReportVoxelInfo (G4LogicalVolume *logVolume, std::ostream &os)
void	SetVerbosity (G4bool verbose)
G4bool	IsParallelOptimisationFinished ()
G4int	CheckOptimisation ()

Static Public Member Functions
static void	ReportVoxelStats (std::vector< G4SmartVoxelStat > &stats, G4double totalCpuTime, std::ostream &os=G4cout)

Detailed Description

G4VoxelisationHelper is a helper class to undertake voxelisation in parallel, aiding and off-loading the work of G4GeometryManager.

Definition at line 59 of file G4VoxelisationHelper.hh.

Constructor & Destructor Documentation

G4VoxelisationHelper()

G4VoxelisationHelper::G4VoxelisationHelper

(

)

Constructor & Destructor.

Definition at line 42 of file G4VoxelisationHelper.cc.

{
  fWallClockTimer = new G4Timer;
 
  ResetListOfVolumesToOptimise();
}

~G4VoxelisationHelper()

G4VoxelisationHelper::~G4VoxelisationHelper

(

)

Definition at line 49 of file G4VoxelisationHelper.cc.

{
  delete fWallClockTimer;
}

Member Function Documentation

CheckOptimisation()

G4int G4VoxelisationHelper::CheckOptimisation

(

)

Check that volumes marked to optimise are done, and report number of those that are missing voxel header.

Definition at line 632 of file G4VoxelisationHelper.cc.

{
  unsigned int numErrors = 0;
  for ( const auto& logical : fVolumesToOptimise )
  {
    if( logical->GetVoxelHeader() == nullptr ) { ++numErrors; }
  }
  return numErrors;
}

Referenced by UndertakeOptimisation().

IsParallelOptimisationFinished()

G4bool G4VoxelisationHelper::IsParallelOptimisationFinished

(

)

Returns true if all workers are finished (or all work is done).

Definition at line 622 of file G4VoxelisationHelper.cc.

{ 
  G4AutoLock lock(&statResultsMutex);
  return fParallelVoxelOptimisationFinished;
}

Referenced by UndertakeOptimisation().

PrepareParallelOptimisation()

void G4VoxelisationHelper::PrepareParallelOptimisation	(	G4bool	allOpts,
		G4bool	verbose )

Key method that creates a list of volumes and resets the state to prepare for the parallel optimisation.

Definition at line 154 of file G4VoxelisationHelper.cc.

{
  if( verbose )
  {
    G4cout << "** G4VoxelisationHelper::PrepareParallelOptimisation() called."
           << " LEAVING all the work (of voxel optimisation) to the threads/tasks !"
           << G4endl;
  }
  CreateListOfVolumesToOptimise(allOpts, verbose);
  ReSetParallelOptimisation(verbose);
}

ReportVoxelInfo()

void G4VoxelisationHelper::ReportVoxelInfo	(	G4LogicalVolume *	logVolume,
		std::ostream &	os )

Definition at line 490 of file G4VoxelisationHelper.cc.

{
  G4SmartVoxelHeader* head = logVolume->GetVoxelHeader();
  if( head != nullptr )
  {
    os << "** Created optimisations for logical-volume '" 
       << std::setw(50) << logVolume->GetName() << "'" << G4endl
       << "- Result VoxelInfo - START: " << " ptr= " << head << G4endl
       << *head
       << "- Result VoxelInfo -   END. " << G4endl;
  }
  else
  {
    os << "** No optimisation for log-vol " << logVolume->GetName() << G4endl;
  }
  os << "*** Report Voxel Info: END " <<  G4endl;
}

ReportVoxelStats()

void G4VoxelisationHelper::ReportVoxelStats ( std::vector< G4SmartVoxelStat > & stats, G4double totalCpuTime, std::ostream & os = G4cout )

static

Methods to report statistics on the voxelisation process.

Definition at line 513 of file G4VoxelisationHelper.cc.

{
  os << "--------------------------------------------------------------------------------"
     << G4endl;
  os << "G4VoxelisationHelper::ReportVoxelStats -- Voxel Statistics"
         << G4endl << G4endl;
 
  //
  // Get total memory use
  //
  G4int i, nStat = (G4int)stats.size();
  G4long totalMemory = 0;
 
  for( i=0; i<nStat; ++i )  { totalMemory += stats[i].GetMemoryUse(); }
 
  os << "    Total memory consumed for geometry optimisation:   "
         << totalMemory/1024 << " kByte" << G4endl;
  os << "    Total CPU time elapsed for geometry optimisation: " 
         << std::setprecision(4) << 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();
  } );
         
  const G4int maxPrint = 20;
  G4int nPrint = std::min ( nStat, maxPrint );
 
  if (nPrint != 0)
  {
    os << "\n    Voxelisation: top CPU users:" << G4endl;
    os << "    Percent   Total CPU    System CPU       Memory  Volume\n"
       << "    -------   ----------   ----------     --------  ----------"
       << G4endl;
  }
 
  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 < CLHEP::perMillion))
      { total = 0; }
    else
      { perc = total*100/totalCpuTime; }
 
    os << 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 != 0)
  {
    os << "\n    Voxelisation: top memory users:" << G4endl;
    os << "    Percent     Memory      Heads    Nodes   Pointers    Total CPU    Volume\n"
       << "    -------   --------     ------   ------   --------   ----------    ----------"
       << G4endl;
  }
 
  for(i=0; i<nPrint; ++i)
  {
    G4long memory = stats[i].GetMemoryUse();
    G4double totTime = stats[i].GetTotalTime();
    if (totTime < 0) { totTime = 0.0; }
 
    os << 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;
  }
  os << "--------------------------------------------------------------------------------"
     << G4endl << G4endl;
}

Referenced by UndertakeOptimisation().

SetVerbosity()

void G4VoxelisationHelper::SetVerbosity ( G4bool verbose )

inline

Sets verbosity mode.

Definition at line 95 of file G4VoxelisationHelper.hh.

{ fVerboseParallel = verbose; }

UndertakeOptimisation()

void G4VoxelisationHelper::UndertakeOptimisation

(

)

Contributes to voxel optimisation until all work is done. To be called by a worker thread initialisation, not by the user.

Definition at line 195 of file G4VoxelisationHelper.cc.

{
  G4bool verbose = fVerboseParallel;
  G4LogicalVolume* logVolume = nullptr;
 
  // Use a mutex to protect parallel writes, but may be better to use atomic,
  // or do away with this entirely since it's not practically used?
  {
    G4AutoLock uo_lock(&statResultsMutex);
    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("G4VoxelisationHelper::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("G4VoxelisationHelper::UndertakeOptimisation()",
                  "GeomMng002", FatalException, errmsg);
    }
    
    // Create report
 
    if( verbose )
    {
      fWallClockTimer->Stop();
 
      std::ostream& report_stream = std::cout; // G4cout; does not work!
      report_stream << G4endl
        << "G4VoxelisationHelper::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);
  }
}

---

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

• G4VoxelisationHelper.hh
• G4VoxelisationHelper.cc