G4RunManager Class Reference

#include <G4RunManager.hh>

Inheritance diagram for G4RunManager:

Public Types
using	ProfilerConfig = G4ProfilerConfig< G4ProfileType::Run >
enum	RMType { sequentialRM , masterRM , workerRM }

Public Member Functions
virtual void	AbortEvent ()
virtual void	AbortRun (G4bool softAbort=false)
virtual void	AnalyzeEvent (G4Event *anEvent)
virtual void	BeamOn (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1)
virtual void	ConfigureProfilers (const std::vector< std::string > &args={})
void	ConfigureProfilers (G4int argc, char **argv)
virtual G4bool	ConfirmBeamOnCondition ()
virtual void	ConstructScoringWorlds ()
void	CutOffHasBeenModified ()
virtual void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
virtual void	DoEventLoop (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1)
void	DumpRegion (const G4String &rname) const
void	DumpRegion (G4Region *region=nullptr) const
	G4RunManager ()
	G4RunManager (const G4RunManager &)=delete
virtual G4Event *	GenerateEvent (G4int i_event)
void	GeometryDirectlyUpdated (G4bool val=true)
void	GeometryHasBeenModified (G4bool prop=true)
const G4Event *	GetCurrentEvent () const
const G4Run *	GetCurrentRun () const
G4int	GetFlagRandomNumberStatusToG4Event () const
G4bool	GetGeometryToBeOptimized ()
G4Run *	GetNonConstCurrentRun () const
G4VUserActionInitialization *	GetNonConstUserActionInitialization () const
G4int	GetNumberOfEventsToBeProcessed () const
G4int	GetNumberOfParallelWorld () const
G4int	GetNumberOfSelectEvents () const
virtual G4int	GetNumberOfThreads () const
const G4Event *	GetPreviousEvent (G4int i) const
G4int	GetPrintProgress ()
const G4String &	GetRandomNumberStatusForThisEvent () const
const G4String &	GetRandomNumberStatusForThisRun () const
G4bool	GetRandomNumberStore () const
const G4String &	GetRandomNumberStoreDir () const
G4bool	GetRandomNumberStorePerEvent () const
RMType	GetRunManagerType () const
const G4String &	GetSelectMacro () const
const G4VUserActionInitialization *	GetUserActionInitialization () const
const G4VUserDetectorConstruction *	GetUserDetectorConstruction () const
const G4UserEventAction *	GetUserEventAction () const
const G4VUserPhysicsList *	GetUserPhysicsList () const
const G4VUserPrimaryGeneratorAction *	GetUserPrimaryGeneratorAction () const
const G4UserRunAction *	GetUserRunAction () const
const G4UserStackingAction *	GetUserStackingAction () const
const G4UserSteppingAction *	GetUserSteppingAction () const
const G4UserTrackingAction *	GetUserTrackingAction () const
const G4UserWorkerInitialization *	GetUserWorkerInitialization () const
const G4UserWorkerThreadInitialization *	GetUserWorkerThreadInitialization () const
G4int	GetVerboseLevel () const
const G4String &	GetVersionString () const
virtual void	Initialize ()
virtual void	InitializeEventLoop (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1)
virtual void	InitializeGeometry ()
virtual void	InitializePhysics ()
G4RunManager &	operator= (const G4RunManager &)=delete
void	PhysicsHasBeenModified ()
virtual void	ProcessOneEvent (G4int i_event)
void	ReinitializeGeometry (G4bool destroyFirst=false, G4bool prop=true)
void	ReOptimize (G4LogicalVolume *)
void	ReOptimizeMotherOf (G4VPhysicalVolume *)
virtual void	RestoreRandomNumberStatus (const G4String &fileN)
virtual void	RestoreRndmEachEvent (G4bool)
virtual void	rndmSaveThisEvent ()
virtual void	rndmSaveThisRun ()
virtual void	RunInitialization ()
virtual void	RunTermination ()
void	SetDCtable (G4DCtable *DCtbl)
void	SetGeometryToBeOptimized (G4bool vl)
void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)
void	SetNumberOfEventsToBeProcessed (G4int val)
void	SetNumberOfEventsToBeStored (G4int val)
virtual void	SetNumberOfThreads (G4int)
void	SetPrimaryTransformer (G4PrimaryTransformer *pt)
void	SetPrintProgress (G4int i)
void	SetRandomNumberStore (G4bool flag)
void	SetRandomNumberStoreDir (const G4String &dir)
void	SetRandomNumberStorePerEvent (G4bool flag)
void	SetRunIDCounter (G4int i)
virtual void	SetUserAction (G4UserEventAction *userAction)
virtual void	SetUserAction (G4UserRunAction *userAction)
virtual void	SetUserAction (G4UserStackingAction *userAction)
virtual void	SetUserAction (G4UserSteppingAction *userAction)
virtual void	SetUserAction (G4UserTrackingAction *userAction)
virtual void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction)
virtual void	SetUserInitialization (G4UserWorkerInitialization *userInit)
virtual void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit)
virtual void	SetUserInitialization (G4VUserActionInitialization *userInit)
virtual void	SetUserInitialization (G4VUserDetectorConstruction *userInit)
virtual void	SetUserInitialization (G4VUserPhysicsList *userInit)
void	SetVerboseLevel (G4int vl)
void	StoreRandomNumberStatusToG4Event (G4int vl)
virtual void	TerminateEventLoop ()
virtual void	TerminateOneEvent ()
virtual	~G4RunManager ()

Static Public Member Functions
static G4RunManager *	GetRunManager ()
static G4bool	IfGeometryHasBeenDestroyed ()

Protected Member Functions
void	CleanUpPreviousEvents ()
void	CleanUpUnnecessaryEvents (G4int keepNEvents)
virtual void	DeleteUserInitializations ()
	G4RunManager (RMType rmType)
void	StackPreviousEvent (G4Event *anEvent)
virtual void	StoreRNGStatus (const G4String &filenamePrefix)
void	UpdateScoring ()

Protected Attributes
G4Event *	currentEvent = nullptr
G4Run *	currentRun = nullptr
G4VPhysicalVolume *	currentWorld = nullptr
G4DCtable *	DCtable = nullptr
G4EventManager *	eventManager = nullptr
G4bool	fakeRun = false
G4bool	geometryDirectlyUpdated = false
G4bool	geometryInitialized = false
G4bool	geometryToBeOptimized = true
G4bool	initializedAtLeastOnce = false
G4bool	isScoreNtupleWriter = false
G4RunManagerKernel *	kernel = nullptr
G4String	msgText = " "
G4int	n_perviousEventsToBeStored = 0
G4int	n_select_msg = -1
G4int	nParallelWorlds = 0
G4int	numberOfEventProcessed = 0
G4int	numberOfEventToBeProcessed = 0
G4bool	physicsInitialized = false
G4VUserPhysicsList *	physicsList = nullptr
std::list< G4Event * > *	previousEvents = nullptr
G4int	printModulo = -1
G4String	randomNumberStatusDir = "./"
G4String	randomNumberStatusForThisEvent = ""
G4String	randomNumberStatusForThisRun = ""
G4bool	rngStatusEventsFlag = false
G4bool	runAborted = false
G4int	runIDCounter = 0
RMType	runManagerType
G4String	selectMacro = ""
G4bool	storeRandomNumberStatus = false
G4int	storeRandomNumberStatusToG4Event = 0
G4Timer *	timer = nullptr
G4VUserActionInitialization *	userActionInitialization = nullptr
G4VUserDetectorConstruction *	userDetector = nullptr
G4UserEventAction *	userEventAction = nullptr
G4VUserPrimaryGeneratorAction *	userPrimaryGeneratorAction = nullptr
G4UserRunAction *	userRunAction = nullptr
G4UserStackingAction *	userStackingAction = nullptr
G4UserSteppingAction *	userSteppingAction = nullptr
G4UserTrackingAction *	userTrackingAction = nullptr
G4UserWorkerInitialization *	userWorkerInitialization = nullptr
G4UserWorkerThreadInitialization *	userWorkerThreadInitialization = nullptr
G4int	verboseLevel = 0

Static Protected Attributes
static G4RUN_DLL G4bool	fGeometryHasBeenDestroyed = false

Private Attributes
std::unique_ptr< ProfilerConfig >	masterRunProfiler
G4RunMessenger *	runMessenger = nullptr

Static Private Attributes
static G4ThreadLocal G4RunManager *	fRunManager = nullptr

Friends
class	G4RunManagerFactory

Detailed Description

Definition at line 137 of file G4RunManager.hh.

Member Typedef Documentation

ProfilerConfig

using G4RunManager::ProfilerConfig = G4ProfilerConfig<G4ProfileType::Run>

Definition at line 143 of file G4RunManager.hh.

Member Enumeration Documentation

RMType

enum G4RunManager::RMType

Enumerator
sequentialRM
masterRM
workerRM

Definition at line 575 of file G4RunManager.hh.

    {
      sequentialRM,
      masterRM,
      workerRM
    };

Constructor & Destructor Documentation

G4RunManager() [1/3]

G4RunManager::G4RunManager

(

)

Definition at line 117 of file G4RunManager.cc.

{
  if(fRunManager)
  {
    G4Exception("G4RunManager::G4RunManager()", "Run0031", FatalException,
                "G4RunManager constructed twice.");
  }
  fRunManager = this;
 
  kernel       = new G4RunManagerKernel();
  eventManager = kernel->GetEventManager();
 
  timer          = new G4Timer();
  runMessenger   = new G4RunMessenger(this);
  previousEvents = new std::list<G4Event*>;
  G4ParticleTable::GetParticleTable()->CreateMessenger();
  G4ProcessTable::GetProcessTable();
  std::ostringstream oss;
  G4Random::saveFullState(oss);
  randomNumberStatusForThisRun   = oss.str();
  randomNumberStatusForThisEvent = oss.str();
  runManagerType                 = sequentialRM;
}

References G4ParticleTable::CreateMessenger(), eventManager, FatalException, fRunManager, G4Exception(), G4RunManagerKernel::GetEventManager(), G4ParticleTable::GetParticleTable(), G4ProcessTable::GetProcessTable(), kernel, previousEvents, randomNumberStatusForThisEvent, randomNumberStatusForThisRun, runManagerType, runMessenger, sequentialRM, and timer.

~G4RunManager()

G4RunManager::~G4RunManager ( )

virtual

Definition at line 197 of file G4RunManager.cc.

{
  // finalise profiler before shutting down the threads
  G4Profiler::Finalize();
  G4StateManager* pStateManager = G4StateManager::GetStateManager();
  // set the application state to the quite state
  if(pStateManager->GetCurrentState() != G4State_Quit)
  {
    if(verboseLevel > 0)
      G4cout << "G4 kernel has come to Quit state." << G4endl;
    pStateManager->SetNewState(G4State_Quit);
  }
 
  CleanUpPreviousEvents();
  delete currentRun;
  delete timer;
  delete runMessenger;
  delete previousEvents;
 
  // The following will work for all RunManager types
  // if derived class does the correct thing in the derived
  // destructor that is: set to zero pointers of
  // user initialization objects for which have no
  // ownership
  DeleteUserInitializations();
  delete userRunAction;
  userRunAction = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserRunAction deleted." << G4endl;
 
  delete userPrimaryGeneratorAction;
  userPrimaryGeneratorAction = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserPrimaryGenerator deleted." << G4endl;
 
  if(verboseLevel > 1)
    G4cout << "RunManager is deleting RunManagerKernel." << G4endl;
 
  delete kernel;
 
  fRunManager = nullptr;
 
  if(verboseLevel > 1)
    G4cout << "RunManager is deleted." << G4endl;
}

References CleanUpPreviousEvents(), currentRun, DeleteUserInitializations(), G4Profiler::Finalize(), fRunManager, G4cout, G4endl, G4State_Quit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), kernel, previousEvents, runMessenger, G4StateManager::SetNewState(), timer, userPrimaryGeneratorAction, userRunAction, and verboseLevel.

G4RunManager() [2/3]

G4RunManager::G4RunManager ( const G4RunManager &  )

delete

G4RunManager() [3/3]

G4RunManager::G4RunManager ( RMType  rmType )

protected

Definition at line 142 of file G4RunManager.cc.

{
  // This version of the constructor should never be called in sequential mode!
#ifndef G4MULTITHREADED
  G4ExceptionDescription msg;
  msg << "Geant4 code is compiled without multi-threading support "
         "(-DG4MULTITHREADED is set to off).";
  msg << " This type of RunManager can only be used in mult-threaded "
         "applications.";
  G4Exception("G4RunManager::G4RunManager(G4bool)", "Run0107",
              FatalException, msg);
#endif
 
  if(fRunManager != nullptr)
  {
    G4Exception("G4RunManager::G4RunManager()", "Run0031", FatalException,
                "G4RunManager constructed twice.");
    return;
  }
  fRunManager = this;
 
  switch(rmType)
  {
    case masterRM:
      kernel = new G4MTRunManagerKernel();
      break;
    case workerRM:
      kernel = new G4WorkerRunManagerKernel();
      break;
    default:
      G4ExceptionDescription msgx;
      msgx << "This type of RunManager can only be used in multi-threaded "
              "applications.";
      G4Exception("G4RunManager::G4RunManager(G4bool)", "Run0108",
                  FatalException, msgx);
      return;
  }
  runManagerType = rmType;
 
  eventManager = kernel->GetEventManager();
 
  timer          = new G4Timer();
  runMessenger   = new G4RunMessenger(this);
  previousEvents = new std::list<G4Event*>;
  G4ParticleTable::GetParticleTable()->CreateMessenger();
  G4ProcessTable::GetProcessTable();
  randomNumberStatusDir = "./";
  std::ostringstream oss;
  G4Random::saveFullState(oss);
  randomNumberStatusForThisRun   = oss.str();
  randomNumberStatusForThisEvent = oss.str();
  ConfigureProfilers();
}

References ConfigureProfilers(), G4ParticleTable::CreateMessenger(), eventManager, FatalException, fRunManager, G4Exception(), G4RunManagerKernel::GetEventManager(), G4ParticleTable::GetParticleTable(), G4ProcessTable::GetProcessTable(), kernel, masterRM, previousEvents, randomNumberStatusDir, randomNumberStatusForThisEvent, randomNumberStatusForThisRun, runManagerType, runMessenger, timer, and workerRM.

Member Function Documentation

AbortEvent()

void G4RunManager::AbortEvent ( )

virtual

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 774 of file G4RunManager.cc.

{
  // This method is valid only for EventProc state
  G4ApplicationState currentState =
    G4StateManager::GetStateManager()->GetCurrentState();
  if(currentState == G4State_EventProc)
  {
    currentEvent->SetEventAborted();
    eventManager->AbortCurrentEvent();
  }
  else
  {
    G4cerr << "Event is not in progress. AbortEevnt() ignored." << G4endl;
  }
}

References G4EventManager::AbortCurrentEvent(), currentEvent, eventManager, G4cerr, G4endl, G4State_EventProc, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), and G4Event::SetEventAborted().

Referenced by export_G4RunManager(), G4ExceptionHandler::Notify(), and G4RunMessenger::SetNewValue().

AbortRun()

void G4RunManager::AbortRun ( G4bool  softAbort = false )

virtual

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 753 of file G4RunManager.cc.

{
  // This method is valid only for GeomClosed or EventProc state
  G4ApplicationState currentState =
    G4StateManager::GetStateManager()->GetCurrentState();
  if(currentState == G4State_GeomClosed || currentState == G4State_EventProc)
  {
    runAborted = true;
    if(currentState == G4State_EventProc && !softAbort)
    {
      currentEvent->SetEventAborted();
      eventManager->AbortCurrentEvent();
    }
  }
  else
  {
    G4cerr << "Run is not in progress. AbortRun() ignored." << G4endl;
  }
}

References G4EventManager::AbortCurrentEvent(), currentEvent, eventManager, G4cerr, G4endl, G4State_EventProc, G4State_GeomClosed, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), runAborted, and G4Event::SetEventAborted().

Referenced by export_G4RunManager(), G4ExceptionHandler::Notify(), and G4RunMessenger::SetNewValue().

AnalyzeEvent()

void G4RunManager::AnalyzeEvent ( G4Event *  anEvent )

virtual

Definition at line 548 of file G4RunManager.cc.

{
  G4VPersistencyManager* fPersM =
    G4VPersistencyManager::GetPersistencyManager();
  if(fPersM != nullptr)
    fPersM->Store(anEvent);
  currentRun->RecordEvent(anEvent);
}

References currentRun, G4VPersistencyManager::GetPersistencyManager(), G4Run::RecordEvent(), and G4VPersistencyManager::Store().

Referenced by ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), and G4WorkerTaskRunManager::ProcessOneEvent().

BeamOn()

void G4RunManager::BeamOn ( G4int  n_event, const char *  macroFile = nullptr, G4int  n_select = -1  )

virtual

Definition at line 273 of file G4RunManager.cc.

{
  if(n_event <= 0)
  {
    fakeRun = true;
  }
  else
  {
    fakeRun = false;
  }
  G4bool cond = ConfirmBeamOnCondition();
  if(cond)
  {
    numberOfEventToBeProcessed = n_event;
    numberOfEventProcessed     = 0;
    ConstructScoringWorlds();
    RunInitialization();
    DoEventLoop(n_event, macroFile, n_select);
    RunTermination();
  }
  fakeRun = false;
}

References ConfirmBeamOnCondition(), ConstructScoringWorlds(), DoEventLoop(), fakeRun, numberOfEventProcessed, numberOfEventToBeProcessed, RunInitialization(), and RunTermination().

Referenced by G4WorkerRunManager::DoWork(), export_G4RunManager(), G4MTRunManager::Initialize(), G4TaskRunManager::Initialize(), G4AdjointSimManager::RunAdjointSimulation(), and G4RunMessenger::SetNewValue().

CleanUpPreviousEvents()

void G4RunManager::CleanUpPreviousEvents ( )

protected

Definition at line 589 of file G4RunManager.cc.

{
  // Delete all events carried over from previous run.
  // This method is invoked at the beginning of the next run
  // or from the destructor of G4RunManager at the very end of
  // the program.
  // N.B. If ToBeKept() is true, the pointer of this event is
  // kept in G4Run of the previous run, and deleted along with
  // the deletion of G4Run.
 
  auto evItr = previousEvents->cbegin();
  while(evItr != previousEvents->cend())
  {
    G4Event* evt = *evItr;
    if(evt != nullptr && !(evt->ToBeKept()))
      delete evt;
    evItr = previousEvents->erase(evItr);
  }
}

References previousEvents, and G4Event::ToBeKept().

Referenced by G4WorkerTaskRunManager::DoCleanup(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and ~G4RunManager().

CleanUpUnnecessaryEvents()

void G4RunManager::CleanUpUnnecessaryEvents ( G4int  keepNEvents )

protected

Definition at line 610 of file G4RunManager.cc.

{
  // Delete events that are no longer necessary for post
  // processing such as visualization.
  // N.B. If ToBeKept() is true, the pointer of this event is
  // kept in G4Run of the previous run, and deleted along with
  // the deletion of G4Run.
 
  auto evItr = previousEvents->cbegin();
  while(evItr != previousEvents->cend())
  {
    if(G4int(previousEvents->size()) <= keepNEvents)
      return;
 
    G4Event* evt = *evItr;
    if(evt != nullptr)
    {
      if(evt->GetNumberOfGrips() == 0)
      {
        if(!(evt->ToBeKept()))
          delete evt;
        evItr = previousEvents->erase(evItr);
      }
      else
      {
        ++evItr;
      }
    }
    else
    {
      evItr = previousEvents->erase(evItr);
    }
  }
}

References G4Event::GetNumberOfGrips(), previousEvents, and G4Event::ToBeKept().

Referenced by RunTermination(), and StackPreviousEvent().

ConfigureProfilers() [1/2]

void G4RunManager::ConfigureProfilers ( const std::vector< std::string > &  args = {} )

virtual

Definition at line 1198 of file G4RunManager.cc.

{
#ifdef GEANT4_USE_TIMEMORY
  // parse command line if arguments were passed
  G4Profiler::Configure(args);
#else
  G4ConsumeParameters(args);
#endif
}

References args, G4Profiler::Configure(), and G4ConsumeParameters().

Referenced by ConfigureProfilers(), and G4RunManager().

ConfigureProfilers() [2/2]

void G4RunManager::ConfigureProfilers	(	G4int	argc,
		char **	argv
	)

Definition at line 1189 of file G4RunManager.cc.

{
  std::vector<std::string> _args;
  for(G4int i = 0; i < argc; ++i)
    _args.push_back(argv[i]);
  ConfigureProfilers(_args);
}

References ConfigureProfilers().

ConfirmBeamOnCondition()

G4bool G4RunManager::ConfirmBeamOnCondition ( )

virtual

Definition at line 297 of file G4RunManager.cc.

{
  G4StateManager* stateManager = G4StateManager::GetStateManager();
 
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_PreInit && currentState != G4State_Idle)
  {
    G4cerr << "Illegal application state - BeamOn() ignored." << G4endl;
    return false;
  }
 
  if(!initializedAtLeastOnce)
  {
    G4cerr << " Geant4 kernel should be initialized" << G4endl;
    G4cerr << "before the first BeamOn(). - BeamOn ignored." << G4endl;
    return false;
  }
 
  if(!geometryInitialized || !physicsInitialized)
  {
    if(verboseLevel > 0)
    {
      G4cout << "Start re-initialization because " << G4endl;
      if(!geometryInitialized)
        G4cout << "  Geometry" << G4endl;
      if(!physicsInitialized)
        G4cout << "  Physics processes" << G4endl;
      G4cout << "has been modified since last Run." << G4endl;
    }
    Initialize();
  }
  return true;
}

References G4cerr, G4cout, G4endl, G4State_Idle, G4State_PreInit, geometryInitialized, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), Initialize(), initializedAtLeastOnce, physicsInitialized, and verboseLevel.

Referenced by BeamOn(), and G4WorkerTaskRunManager::DoWork().

ConstructScoringWorlds()

void G4RunManager::ConstructScoringWorlds ( )

virtual

Reimplemented in G4MTRunManager, G4WorkerRunManager, and G4TaskRunManager.

Definition at line 902 of file G4RunManager.cc.

{
  using MeshShape = G4VScoringMesh::MeshShape;
 
  G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
  if(ScM == nullptr)
    return;
 
  G4int nPar = ScM->GetNumberOfMesh();
  if(nPar < 1)
    return;
 
  auto theParticleIterator = G4ParticleTable::GetParticleTable()->GetIterator();
  for(G4int iw = 0; iw < nPar; ++iw)
  {
    G4VScoringMesh* mesh = ScM->GetMesh(iw);
    if(fGeometryHasBeenDestroyed)
      mesh->GeometryHasBeenDestroyed();
    G4VPhysicalVolume* pWorld = nullptr;
    if(mesh->GetShape() != MeshShape::realWorldLogVol)
    {
      pWorld = G4TransportationManager::GetTransportationManager()
             ->IsWorldExisting(ScM->GetWorldName(iw));
      if(pWorld == nullptr)
      {
        pWorld = G4TransportationManager::GetTransportationManager()
               ->GetParallelWorld(ScM->GetWorldName(iw));
        pWorld->SetName(ScM->GetWorldName(iw));
 
        G4ParallelWorldProcess* theParallelWorldProcess =
          mesh->GetParallelWorldProcess();
        if(theParallelWorldProcess != nullptr)
        {
          theParallelWorldProcess->SetParallelWorld(ScM->GetWorldName(iw));
        }
        else
        {
          theParallelWorldProcess =
            new G4ParallelWorldProcess(ScM->GetWorldName(iw));
          mesh->SetParallelWorldProcess(theParallelWorldProcess);
          theParallelWorldProcess->SetParallelWorld(ScM->GetWorldName(iw));
 
          theParticleIterator->reset();
          while((*theParticleIterator)())
          {
            G4ParticleDefinition* particle = theParticleIterator->value();
            G4ProcessManager* pmanager     = particle->GetProcessManager();
            if(pmanager != nullptr)
            {
              pmanager->AddProcess(theParallelWorldProcess);
              if(theParallelWorldProcess->IsAtRestRequired(particle))
              {
                pmanager->SetProcessOrdering(theParallelWorldProcess, idxAtRest,
                                             9900);
              }
              pmanager->SetProcessOrderingToSecond(theParallelWorldProcess,
                                                   idxAlongStep);
              pmanager->SetProcessOrdering(theParallelWorldProcess, idxPostStep,
                                           9900);
            }
          }
        }
        theParallelWorldProcess->SetLayeredMaterialFlag(mesh->LayeredMassFlg());
      }
    }
    mesh->Construct(pWorld);
  }
  GeometryHasBeenModified();
}

References G4ProcessManager::AddProcess(), G4VScoringMesh::Construct(), fGeometryHasBeenDestroyed, G4VScoringMesh::GeometryHasBeenDestroyed(), GeometryHasBeenModified(), G4ParticleTable::GetIterator(), G4ScoringManager::GetMesh(), G4ScoringManager::GetNumberOfMesh(), G4TransportationManager::GetParallelWorld(), G4VScoringMesh::GetParallelWorldProcess(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), G4ScoringManager::GetScoringManagerIfExist(), G4VScoringMesh::GetShape(), G4TransportationManager::GetTransportationManager(), G4ScoringManager::GetWorldName(), idxAlongStep, idxAtRest, idxPostStep, G4ParallelWorldProcess::IsAtRestRequired(), G4TransportationManager::IsWorldExisting(), G4VScoringMesh::LayeredMassFlg(), G4ParallelWorldProcess::SetLayeredMaterialFlag(), G4VPhysicalVolume::SetName(), G4ParallelWorldProcess::SetParallelWorld(), G4VScoringMesh::SetParallelWorldProcess(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToSecond(), and theParticleIterator.

Referenced by BeamOn(), G4MTRunManager::ConstructScoringWorlds(), G4TaskRunManager::ConstructScoringWorlds(), and G4RunMessenger::SetNewValue().

CutOffHasBeenModified()

void G4RunManager::CutOffHasBeenModified ( )

inline

Definition at line 301 of file G4RunManager.hh.

    {
      G4cerr << "CutOffHasBeenModified becomes obsolete." << G4endl;
      G4cerr << "It is safe to remove invoking this method." << G4endl;
    }

References G4cerr, and G4endl.

DefineWorldVolume()

void G4RunManager::DefineWorldVolume ( G4VPhysicalVolume *  worldVol, G4bool  topologyIsChanged = true  )

virtual

Definition at line 791 of file G4RunManager.cc.

{
  kernel->DefineWorldVolume(worldVol, topologyIsChanged);
}

References G4RunManagerKernel::DefineWorldVolume(), and kernel.

Referenced by export_G4RunManager(), DetectorConstruction::SetMaterial(), G4GDMLMessenger::SetNewValue(), and ExN03DetectorConstruction::UpdateGeometry().

DeleteUserInitializations()

void G4RunManager::DeleteUserInitializations ( )

protectedvirtual

Definition at line 244 of file G4RunManager.cc.

{
  delete userDetector;
  userDetector = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserDetectorConstruction deleted." << G4endl;
 
  delete physicsList;
  physicsList = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserPhysicsList deleted." << G4endl;
 
  delete userActionInitialization;
  userActionInitialization = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserActionInitialization deleted." << G4endl;
 
  delete userWorkerInitialization;
  userWorkerInitialization = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserWorkerInitialization deleted." << G4endl;
 
  delete userWorkerThreadInitialization;
  userWorkerThreadInitialization = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserWorkerThreadInitialization deleted." << G4endl;
}

References G4cout, G4endl, physicsList, userActionInitialization, userDetector, userWorkerInitialization, userWorkerThreadInitialization, and verboseLevel.

Referenced by ~G4RunManager().

DoEventLoop()

void G4RunManager::DoEventLoop ( G4int  n_event, const char *  macroFile = nullptr, G4int  n_select = -1  )

virtual

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 412 of file G4RunManager.cc.

{
  InitializeEventLoop(n_event, macroFile, n_select);
 
  // Event loop
  for(G4int i_event = 0; i_event < n_event; ++i_event)
  {
    ProcessOneEvent(i_event);
    TerminateOneEvent();
    if(runAborted)
      break;
  }
 
  // For G4MTRunManager, TerminateEventLoop() is invoked after all threads are
  // finished.
  if(runManagerType == sequentialRM)
    TerminateEventLoop();
}

References InitializeEventLoop(), ProcessOneEvent(), runAborted, runManagerType, sequentialRM, TerminateEventLoop(), and TerminateOneEvent().

Referenced by BeamOn().

DumpRegion() [1/2]

void G4RunManager::DumpRegion

(

const G4String &

rname

)

const

Definition at line 890 of file G4RunManager.cc.

{
  kernel->DumpRegion(rname);
}

References G4RunManagerKernel::DumpRegion(), and kernel.

Referenced by G4RunMessenger::SetNewValue().

DumpRegion() [2/2]

void G4RunManager::DumpRegion

(

G4Region *

region = nullptr

)

const

Definition at line 896 of file G4RunManager.cc.

{
  kernel->DumpRegion(region);
}

References G4RunManagerKernel::DumpRegion(), and kernel.

GenerateEvent()

G4Event * G4RunManager::GenerateEvent ( G4int  i_event )

virtual

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 500 of file G4RunManager.cc.

{
  if(userPrimaryGeneratorAction == nullptr)
  {
    G4Exception("G4RunManager::GenerateEvent()", "Run0032", FatalException,
                "G4VUserPrimaryGeneratorAction is not defined!");
    return nullptr;
  }
 
  G4Event* anEvent = new G4Event(i_event);
 
  if(storeRandomNumberStatusToG4Event == 1 ||
     storeRandomNumberStatusToG4Event == 3)
  {
    std::ostringstream oss;
    G4Random::saveFullState(oss);
    randomNumberStatusForThisEvent = oss.str();
    anEvent->SetRandomNumberStatus(randomNumberStatusForThisEvent);
  }
 
  if(storeRandomNumberStatus)
  {
    G4String fileN = "currentEvent";
    if(rngStatusEventsFlag)
    {
      std::ostringstream os;
      os << "run" << currentRun->GetRunID() << "evt" << anEvent->GetEventID();
      fileN = os.str();
    }
    StoreRNGStatus(fileN);
  }
 
  if(printModulo > 0 && anEvent->GetEventID() % printModulo == 0)
  {
    G4cout << "--> Event " << anEvent->GetEventID() << " starts." << G4endl;
  }
  userPrimaryGeneratorAction->GeneratePrimaries(anEvent);
  return anEvent;
}

References currentRun, FatalException, G4cout, G4endl, G4Exception(), G4VUserPrimaryGeneratorAction::GeneratePrimaries(), G4Event::GetEventID(), G4Run::GetRunID(), printModulo, randomNumberStatusForThisEvent, rngStatusEventsFlag, G4Event::SetRandomNumberStatus(), storeRandomNumberStatus, storeRandomNumberStatusToG4Event, StoreRNGStatus(), and userPrimaryGeneratorAction.

Referenced by ProcessOneEvent().

GeometryDirectlyUpdated()

void G4RunManager::GeometryDirectlyUpdated ( G4bool  val = true )

inline

Definition at line 331 of file G4RunManager.hh.

    {
      geometryDirectlyUpdated = val;
    }

References geometryDirectlyUpdated.

Referenced by G4GDMLMessenger::SetNewValue().

GeometryHasBeenModified()

void G4RunManager::GeometryHasBeenModified

(

G4bool

prop = true

)

Definition at line 1117 of file G4RunManager.cc.

{
  if(prop)
  {
    G4UImanager::GetUIpointer()->ApplyCommand("/run/geometryModified");
  }
  else
  {
    kernel->GeometryHasBeenModified();
  }
}

References G4UImanager::ApplyCommand(), G4RunManagerKernel::GeometryHasBeenModified(), G4UImanager::GetUIpointer(), and kernel.

Referenced by ConstructScoringWorlds(), export_G4RunManager(), and G4RunMessenger::SetNewValue().

GetCurrentEvent()

const G4Event * G4RunManager::GetCurrentEvent ( ) const

inline

Definition at line 537 of file G4RunManager.hh.

{ return currentEvent; }

References currentEvent.

Referenced by export_G4RunManager(), G4DigiManager::GetDigiCollection(), G4DigiManager::GetHitsCollection(), and G4DigiManager::SetDigiCollection().

GetCurrentRun()

const G4Run * G4RunManager::GetCurrentRun ( ) const

inline

Definition at line 533 of file G4RunManager.hh.

{ return currentRun; }

References currentRun.

Referenced by G4TheMTRayTracer::CreateBitMap(), G4TrajectoriesModel::DescribeYourselfTo(), G4WorkerTaskRunManager::DoWork(), G4VisManager::Draw(), G4VisManager::Enable(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), export_G4RunManager(), G4VisCommandSceneAddEventID::EventID::operator()(), G4VSceneHandler::ProcessScene(), G4OpenGLSceneHandler::ScaledFlush(), G4VisCommandReviewKeptEvents::SetNewValue(), and G4VisCommandSceneEndOfEventAction::SetNewValue().

GetFlagRandomNumberStatusToG4Event()

G4int G4RunManager::GetFlagRandomNumberStatusToG4Event ( ) const

inline

Definition at line 451 of file G4RunManager.hh.

    {
      return storeRandomNumberStatusToG4Event;
    }

References storeRandomNumberStatusToG4Event.

Referenced by G4RunMessenger::GetCurrentValue().

GetGeometryToBeOptimized()

G4bool G4RunManager::GetGeometryToBeOptimized ( )

inline

Definition at line 326 of file G4RunManager.hh.

    {
      return geometryToBeOptimized;
    }

References geometryToBeOptimized.

Referenced by export_G4RunManager().

GetNonConstCurrentRun()

G4Run * G4RunManager::GetNonConstCurrentRun ( ) const

inline

Definition at line 534 of file G4RunManager.hh.

{ return currentRun; }

References currentRun.

GetNonConstUserActionInitialization()

G4VUserActionInitialization * G4RunManager::GetNonConstUserActionInitialization ( ) const

inline

Definition at line 384 of file G4RunManager.hh.

    {
      return userActionInitialization;
    }

References userActionInitialization.

Referenced by G4TaskRunManagerKernel::InitializeWorker(), and G4MTRunManagerKernel::StartThread().

GetNumberOfEventsToBeProcessed()

G4int G4RunManager::GetNumberOfEventsToBeProcessed ( ) const

inline

Definition at line 567 of file G4RunManager.hh.

    {
      return numberOfEventToBeProcessed;
    }

References numberOfEventToBeProcessed.

Referenced by G4VisManager::BeginOfRun(), G4WorkerRunManager::DoWork(), G4WorkerTaskRunManager::DoWork(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), and G4WorkerTaskRunManager::RunInitialization().

GetNumberOfParallelWorld()

G4int G4RunManager::GetNumberOfParallelWorld ( ) const

inline

Definition at line 562 of file G4RunManager.hh.

{ return nParallelWorlds; }

References nParallelWorlds.

GetNumberOfSelectEvents()

G4int G4RunManager::GetNumberOfSelectEvents ( ) const

inline

Definition at line 571 of file G4RunManager.hh.

{ return n_select_msg; }

References n_select_msg.

Referenced by G4WorkerRunManager::DoWork(), and G4WorkerTaskRunManager::DoWork().

GetNumberOfThreads()

virtual G4int G4RunManager::GetNumberOfThreads ( ) const

inlinevirtual

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 265 of file G4RunManager.hh.

{ return 1; }

GetPreviousEvent()

const G4Event * G4RunManager::GetPreviousEvent ( G4int  i ) const

inline

Definition at line 540 of file G4RunManager.hh.

    {
      if(i >= 1 && i <= n_perviousEventsToBeStored)
      {
        auto itr = previousEvents->cbegin();
        for(G4int j = 1; j < i; ++j)
        {
          ++itr;
        }
        return *itr;
      }
      return nullptr;
    }

References n_perviousEventsToBeStored, and previousEvents.

Referenced by G4DigiManager::GetDigiCollection(), and G4DigiManager::GetHitsCollection().

GetPrintProgress()

G4int G4RunManager::GetPrintProgress ( )

inline

Definition at line 521 of file G4RunManager.hh.

{ return printModulo; }

References printModulo.

Referenced by G4TheMTRayTracer::CreateBitMap(), and G4RunMessenger::GetCurrentValue().

GetRandomNumberStatusForThisEvent()

const G4String & G4RunManager::GetRandomNumberStatusForThisEvent ( ) const

inline

Definition at line 495 of file G4RunManager.hh.

    {
      if(storeRandomNumberStatusToG4Event == 0 ||
         storeRandomNumberStatusToG4Event == 2)
      {
        G4Exception("GrRunManager::SetRandomNumberStoreDir", "Run0072",
                    JustWarning,
                    "Random number status is not available for this event.");
      }
      return randomNumberStatusForThisEvent;
    }

References G4Exception(), JustWarning, randomNumberStatusForThisEvent, and storeRandomNumberStatusToG4Event.

GetRandomNumberStatusForThisRun()

const G4String & G4RunManager::GetRandomNumberStatusForThisRun ( ) const

inline

Definition at line 491 of file G4RunManager.hh.

    {
      return randomNumberStatusForThisRun;
    }

References randomNumberStatusForThisRun.

GetRandomNumberStore()

G4bool G4RunManager::GetRandomNumberStore ( ) const

inline

Definition at line 460 of file G4RunManager.hh.

    {
      return storeRandomNumberStatus;
    }

References storeRandomNumberStatus.

Referenced by export_G4RunManager().

GetRandomNumberStoreDir()

const G4String & G4RunManager::GetRandomNumberStoreDir ( ) const

inline

Definition at line 487 of file G4RunManager.hh.

    {
      return randomNumberStatusDir;
    }

References randomNumberStatusDir.

Referenced by export_G4RunManager(), and G4RunMessenger::GetCurrentValue().

GetRandomNumberStorePerEvent()

G4bool G4RunManager::GetRandomNumberStorePerEvent ( ) const

inline

Definition at line 510 of file G4RunManager.hh.

    {
      return rngStatusEventsFlag;
    }

References rngStatusEventsFlag.

GetRunManager()

G4RunManager * G4RunManager::GetRunManager ( )

static

Definition at line 111 of file G4RunManager.cc.

{
  return fRunManager;
}

References fRunManager.

Referenced by pyEMSTDpl::Construct(), pyExN03geom::Construct(), pyExN01pl::Construct(), pyEZgeom::Construct(), pyMedicalBeam::Construct(), pyParticleGun::Construct(), pyQgeom::Construct(), G4AdjointSimManager::DefineUserActions(), G4VisManager::Enable(), export_G4RunManager(), G4DigiManager::G4DigiManager(), G4RunManagerFactory::GetMasterRunManager(), G4RunManagerFactory::GetMasterRunManagerKernel(), G4WorkerRunManager::GetWorkerRunManager(), G4WorkerTaskRunManager::GetWorkerRunManager(), G4ErrorRunManagerHelper::InitializePhysics(), G4ExceptionHandler::Notify(), G4EzWorld::Reset(), G4AdjointSimManager::ResetRestOfUserActions(), G4AdjointSimManager::ResetUserActions(), G4AdjointSimManager::ResetUserPrimaryRunAndStackingActions(), G4EzWorld::Resize(), G4AdjointSimManager::RunAdjointSimulation(), G4AdjointSimManager::SetAdjointActions(), G4AdjointSimManager::SetAdjointPrimaryRunAndStackingActions(), DetectorConstruction::SetMaterial(), G4GDMLMessenger::SetNewValue(), G4AdjointSimMessenger::SetNewValue(), G4AdjointSimManager::SetRestOfAdjointActions(), G4VUserActionInitialization::SetUserAction(), ExN03DetectorConstruction::UpdateGeometry(), and G4Run::~G4Run().

GetRunManagerType()

RMType G4RunManager::GetRunManagerType ( ) const

inline

Definition at line 582 of file G4RunManager.hh.

{ return runManagerType; }

References runManagerType.

Referenced by G4RunMessenger::GetCurrentValue(), G4RunMessenger::SetNewValue(), and G4Run::~G4Run().

GetSelectMacro()

const G4String & G4RunManager::GetSelectMacro ( ) const

inline

Definition at line 572 of file G4RunManager.hh.

{ return selectMacro; }

References selectMacro.

Referenced by G4WorkerRunManager::DoWork(), and G4WorkerTaskRunManager::DoWork().

GetUserActionInitialization()

const G4VUserActionInitialization * G4RunManager::GetUserActionInitialization ( ) const

inline

Definition at line 380 of file G4RunManager.hh.

    {
      return userActionInitialization;
    }

References userActionInitialization.

Referenced by G4TaskRunManagerKernel::InitializeWorker(), and G4MTRunManagerKernel::StartThread().

GetUserDetectorConstruction()

const G4VUserDetectorConstruction * G4RunManager::GetUserDetectorConstruction ( ) const

inline

Definition at line 372 of file G4RunManager.hh.

    {
      return userDetector;
    }

References userDetector.

Referenced by export_G4RunManager(), G4TaskRunManagerKernel::InitializeWorker(), and G4MTRunManagerKernel::StartThread().

GetUserEventAction()

const G4UserEventAction * G4RunManager::GetUserEventAction ( ) const

inline

Definition at line 404 of file G4RunManager.hh.

    {
      return userEventAction;
    }

References userEventAction.

Referenced by G4AdjointSimManager::DefineUserActions(), export_G4RunManager(), and G4RTWorkerInitialization::WorkerRunStart().

GetUserPhysicsList()

const G4VUserPhysicsList * G4RunManager::GetUserPhysicsList ( ) const

inline

Definition at line 376 of file G4RunManager.hh.

    {
      return physicsList;
    }

References physicsList.

Referenced by export_G4RunManager(), G4TaskRunManagerKernel::InitializeWorker(), and G4MTRunManagerKernel::StartThread().

GetUserPrimaryGeneratorAction()

const G4VUserPrimaryGeneratorAction * G4RunManager::GetUserPrimaryGeneratorAction ( ) const

inline

Definition at line 400 of file G4RunManager.hh.

    {
      return userPrimaryGeneratorAction;
    }

References userPrimaryGeneratorAction.

Referenced by G4AdjointSimManager::DefineUserActions(), export_G4RunManager(), and G4RTWorkerInitialization::WorkerRunStart().

GetUserRunAction()

const G4UserRunAction * G4RunManager::GetUserRunAction ( ) const

inline

Definition at line 396 of file G4RunManager.hh.

    {
      return userRunAction;
    }

References userRunAction.

Referenced by G4AdjointSimManager::DefineUserActions(), export_G4RunManager(), G4TheMTRayTracer::StoreUserActions(), and G4RTWorkerInitialization::WorkerRunStart().

GetUserStackingAction()

const G4UserStackingAction * G4RunManager::GetUserStackingAction ( ) const

inline

Definition at line 408 of file G4RunManager.hh.

    {
      return userStackingAction;
    }

References userStackingAction.

Referenced by G4AdjointSimManager::DefineUserActions(), export_G4RunManager(), and G4RTWorkerInitialization::WorkerRunStart().

GetUserSteppingAction()

const G4UserSteppingAction * G4RunManager::GetUserSteppingAction ( ) const

inline

Definition at line 416 of file G4RunManager.hh.

    {
      return userSteppingAction;
    }

References userSteppingAction.

Referenced by G4AdjointSimManager::DefineUserActions(), export_G4RunManager(), and G4RTWorkerInitialization::WorkerRunStart().

GetUserTrackingAction()

const G4UserTrackingAction * G4RunManager::GetUserTrackingAction ( ) const

inline

Definition at line 412 of file G4RunManager.hh.

    {
      return userTrackingAction;
    }

References userTrackingAction.

Referenced by G4AdjointSimManager::DefineUserActions(), export_G4RunManager(), and G4RTWorkerInitialization::WorkerRunStart().

GetUserWorkerInitialization()

const G4UserWorkerInitialization * G4RunManager::GetUserWorkerInitialization ( ) const

inline

Definition at line 388 of file G4RunManager.hh.

    {
      return userWorkerInitialization;
    }

References userWorkerInitialization.

Referenced by G4TaskRunManagerKernel::InitializeWorker(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4WorkerRunManager::RunTermination(), G4WorkerTaskRunManager::RunTermination(), G4MTRunManagerKernel::StartThread(), G4TheMTRayTracer::StoreUserActions(), and G4TaskRunManagerKernel::TerminateWorker().

GetUserWorkerThreadInitialization()

const G4UserWorkerThreadInitialization * G4RunManager::GetUserWorkerThreadInitialization ( ) const

inline

Definition at line 392 of file G4RunManager.hh.

    {
      return userWorkerThreadInitialization;
    }

References userWorkerThreadInitialization.

Referenced by G4TaskRunManagerKernel::InitializeWorker(), G4WorkerRunManager::SetupDefaultRNGEngine(), G4WorkerTaskRunManager::SetupDefaultRNGEngine(), and G4MTRunManagerKernel::StartThread().

GetVerboseLevel()

G4int G4RunManager::GetVerboseLevel ( ) const

inline

Definition at line 520 of file G4RunManager.hh.

{ return verboseLevel; }

References verboseLevel.

Referenced by G4TheMTRayTracer::CreateBitMap(), export_G4RunManager(), and G4RunMessenger::GetCurrentValue().

GetVersionString()

const G4String & G4RunManager::GetVersionString ( ) const

inline

Definition at line 431 of file G4RunManager.hh.

    {
      return kernel->GetVersionString();
    }

References G4RunManagerKernel::GetVersionString(), and kernel.

Referenced by export_G4RunManager().

IfGeometryHasBeenDestroyed()

G4bool G4RunManager::IfGeometryHasBeenDestroyed ( )

static

Definition at line 105 of file G4RunManager.cc.

{
  return fGeometryHasBeenDestroyed;
}

References fGeometryHasBeenDestroyed.

Referenced by G4WorkerTaskRunManager::RunInitialization().

Initialize()

void G4RunManager::Initialize ( void  )

virtual

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 667 of file G4RunManager.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_PreInit && currentState != G4State_Idle)
  {
    G4cerr << "Illegal application state - "
           << "G4RunManager::Initialize() ignored." << G4endl;
    return;
  }
 
  stateManager->SetNewState(G4State_Init);
  if(!geometryInitialized)
    InitializeGeometry();
  if(!physicsInitialized)
    InitializePhysics();
  initializedAtLeastOnce = true;
  if(stateManager->GetCurrentState() != G4State_Idle)
  {
    stateManager->SetNewState(G4State_Idle);
  }
}

References G4cerr, G4endl, G4State_Idle, G4State_Init, G4State_PreInit, geometryInitialized, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), initializedAtLeastOnce, InitializeGeometry(), InitializePhysics(), physicsInitialized, and G4StateManager::SetNewState().

Referenced by ConfirmBeamOnCondition(), export_G4RunManager(), G4MTRunManager::Initialize(), G4TaskRunManager::Initialize(), G4RunMessenger::SetNewValue(), and G4MTRunManagerKernel::StartThread().

InitializeEventLoop()

void G4RunManager::InitializeEventLoop ( G4int  n_event, const char *  macroFile = nullptr, G4int  n_select = -1  )

virtual

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 433 of file G4RunManager.cc.

{
  if(verboseLevel > 0)
  {
    timer->Start();
  }
 
  n_select_msg = n_select;
  if(macroFile != 0)
  {
    if(n_select_msg < 0)
      n_select_msg = n_event;
    msgText = "/control/execute ";
    msgText += macroFile;
    selectMacro = macroFile;
  }
  else
  {
    n_select_msg = -1;
    selectMacro  = "";
  }
}

References msgText, n_select_msg, selectMacro, G4Timer::Start(), timer, and verboseLevel.

Referenced by G4WorkerRunManager::DoEventLoop(), DoEventLoop(), and G4WorkerTaskRunManager::DoEventLoop().

InitializeGeometry()

void G4RunManager::InitializeGeometry ( )

virtual

Reimplemented in G4WorkerRunManager.

Definition at line 691 of file G4RunManager.cc.

{
  if(userDetector == nullptr)
  {
    G4Exception("G4RunManager::InitializeGeometry", "Run0033", FatalException,
                "G4VUserDetectorConstruction is not defined!");
    return;
  }
 
  if(verboseLevel > 1)
    G4cout << "userDetector->Construct() start." << G4endl;
 
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState == G4State_PreInit || currentState == G4State_Idle)
  {
    stateManager->SetNewState(G4State_Init);
  }
  if(!geometryDirectlyUpdated)
  {
    kernel->DefineWorldVolume(userDetector->Construct(), false);
    userDetector->ConstructSDandField();
    nParallelWorlds = userDetector->ConstructParallelGeometries();
    userDetector->ConstructParallelSD();
    kernel->SetNumberOfParallelWorld(nParallelWorlds);
  }
  // Notify the VisManager as well
  if(G4Threading::IsMasterThread())
  {
    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
    if(pVVisManager != nullptr)
      pVVisManager->GeometryHasChanged();
  }
 
  geometryDirectlyUpdated = false;
  geometryInitialized     = true;
  stateManager->SetNewState(currentState);
}

References G4VUserDetectorConstruction::Construct(), G4VUserDetectorConstruction::ConstructParallelGeometries(), G4VUserDetectorConstruction::ConstructParallelSD(), G4VUserDetectorConstruction::ConstructSDandField(), G4RunManagerKernel::DefineWorldVolume(), FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, geometryDirectlyUpdated, G4VVisManager::GeometryHasChanged(), geometryInitialized, G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4Threading::IsMasterThread(), kernel, nParallelWorlds, G4StateManager::SetNewState(), G4RunManagerKernel::SetNumberOfParallelWorld(), userDetector, and verboseLevel.

Referenced by Initialize().

InitializePhysics()

void G4RunManager::InitializePhysics ( )

virtual

Definition at line 731 of file G4RunManager.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState == G4State_PreInit || currentState == G4State_Idle)
  {
    stateManager->SetNewState(G4State_Init);
  }
  if(physicsList != nullptr)
  {
    kernel->InitializePhysics();
  }
  else
  {
    G4Exception("G4RunManager::InitializePhysics()", "Run0034", FatalException,
                "G4VUserPhysicsList is not defined!");
  }
  physicsInitialized = true;
  stateManager->SetNewState(currentState);
}

References FatalException, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4RunManagerKernel::InitializePhysics(), kernel, physicsInitialized, physicsList, and G4StateManager::SetNewState().

Referenced by Initialize().

operator=()

G4RunManager & G4RunManager::operator= ( const G4RunManager &  )

delete

PhysicsHasBeenModified()

void G4RunManager::PhysicsHasBeenModified ( )

inline

Definition at line 294 of file G4RunManager.hh.

{ kernel->PhysicsHasBeenModified(); }

References kernel, and G4RunManagerKernel::PhysicsHasBeenModified().

Referenced by export_G4RunManager(), and G4RunMessenger::SetNewValue().

ProcessOneEvent()

void G4RunManager::ProcessOneEvent ( G4int  i_event )

virtual

Reimplemented in G4MTRunManager, G4WorkerRunManager, G4TaskRunManager, and G4WorkerTaskRunManager.

Definition at line 458 of file G4RunManager.cc.

{
  currentEvent = GenerateEvent(i_event);
  eventManager->ProcessOneEvent(currentEvent);
  AnalyzeEvent(currentEvent);
  UpdateScoring();
  if(i_event < n_select_msg)
    G4UImanager::GetUIpointer()->ApplyCommand(msgText);
}

References AnalyzeEvent(), G4UImanager::ApplyCommand(), currentEvent, eventManager, GenerateEvent(), G4UImanager::GetUIpointer(), msgText, n_select_msg, G4EventManager::ProcessOneEvent(), and UpdateScoring().

Referenced by DoEventLoop().

ReinitializeGeometry()

void G4RunManager::ReinitializeGeometry	(	G4bool	destroyFirst = false,
		G4bool	prop = true
	)

Definition at line 1130 of file G4RunManager.cc.

{
  if(destroyFirst && G4Threading::IsMasterThread())
  {
    if(verboseLevel > 0)
    {
      G4cout << "#### Assemblies, Volumes and Solids Stores are wiped out."
             << G4endl;
    }
    G4GeometryManager::GetInstance()->OpenGeometry();
    G4AssemblyStore::GetInstance()->Clean();
    G4PhysicalVolumeStore::GetInstance()->Clean();
    G4LogicalVolumeStore::GetInstance()->Clean();
    G4SolidStore::GetInstance()->Clean();
 
    // remove all logical volume pointers from regions
    // exception: world logical volume pointer must be kept
    G4RegionStore* regionStore = G4RegionStore::GetInstance();
    for(auto rItr = regionStore->cbegin(); rItr != regionStore->cend(); ++rItr)
    {
      if((*rItr)->GetName() == "DefaultRegionForTheWorld")
        continue;
      // if((*rItr)->GetName()=="DefaultRegionForParallelWorld") continue;
      auto lvItr = (*rItr)->GetRootLogicalVolumeIterator();
      for(std::size_t iRLV=0; iRLV<(*rItr)->GetNumberOfRootVolumes(); ++iRLV)
      {
        (*rItr)->RemoveRootLogicalVolume(*lvItr, false);
        ++lvItr;
      }
      if(verboseLevel > 0)
      {
        G4cout << "#### Region <" << (*rItr)->GetName() << "> is cleared."
               << G4endl;
      }
    }
 
    // clear transportation manager
    fGeometryHasBeenDestroyed = true;
    G4TransportationManager::GetTransportationManager()->ClearParallelWorlds();
  }
  if(prop)
  {
    G4UImanager::GetUIpointer()->ApplyCommand("/run/reinitializeGeometry");
  }
  else
  {
    kernel->GeometryHasBeenModified();
    geometryInitialized = false;
    // Notify the VisManager as well
    if(G4Threading::IsMasterThread())
    {
      G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
      if(pVVisManager != nullptr)
        pVVisManager->GeometryHasChanged();
    }
  }
}

References G4UImanager::ApplyCommand(), G4LogicalVolumeStore::Clean(), G4PhysicalVolumeStore::Clean(), G4SolidStore::Clean(), G4AssemblyStore::Clean(), G4TransportationManager::ClearParallelWorlds(), fGeometryHasBeenDestroyed, G4cout, G4endl, G4RunManagerKernel::GeometryHasBeenModified(), G4VVisManager::GeometryHasChanged(), geometryInitialized, G4VVisManager::GetConcreteInstance(), G4GeometryManager::GetInstance(), G4LogicalVolumeStore::GetInstance(), G4PhysicalVolumeStore::GetInstance(), G4RegionStore::GetInstance(), G4SolidStore::GetInstance(), G4AssemblyStore::GetInstance(), G4TransportationManager::GetTransportationManager(), G4UImanager::GetUIpointer(), G4Threading::IsMasterThread(), kernel, G4GeometryManager::OpenGeometry(), and verboseLevel.

Referenced by G4GDMLMessenger::SetNewValue(), and G4RunMessenger::SetNewValue().

ReOptimize()

void G4RunManager::ReOptimize

(

G4LogicalVolume *

pLog

)

Definition at line 1009 of file G4RunManager.cc.

{
  G4Timer localtimer;
  if(verboseLevel > 1)
  {
    localtimer.Start();
  }
  G4SmartVoxelHeader* header = pLog->GetVoxelHeader();
  delete header;
  header = new G4SmartVoxelHeader(pLog);
  pLog->SetVoxelHeader(header);
  if(verboseLevel > 1)
  {
    localtimer.Stop();
    G4SmartVoxelStat stat(pLog, header, localtimer.GetSystemElapsed(),
                          localtimer.GetUserElapsed());
    G4cout << G4endl << "Voxelisation of logical volume <" << pLog->GetName()
           << ">" << G4endl;
    G4cout << " heads : " << stat.GetNumberHeads()
           << " - nodes : " << stat.GetNumberNodes()
           << " - pointers : " << stat.GetNumberPointers() << G4endl;
    G4cout << " Memory used : " << (stat.GetMemoryUse() + 512) / 1024
           << "k - total time : " << stat.GetTotalTime()
           << " - system time : " << stat.GetSysTime() << G4endl;
  }
}

References G4cout, G4endl, G4SmartVoxelStat::GetMemoryUse(), G4LogicalVolume::GetName(), G4SmartVoxelStat::GetNumberHeads(), G4SmartVoxelStat::GetNumberNodes(), G4SmartVoxelStat::GetNumberPointers(), G4Timer::GetSystemElapsed(), G4SmartVoxelStat::GetSysTime(), G4SmartVoxelStat::GetTotalTime(), G4Timer::GetUserElapsed(), G4LogicalVolume::GetVoxelHeader(), G4LogicalVolume::SetVoxelHeader(), G4Timer::Start(), G4Timer::Stop(), and verboseLevel.

Referenced by ReOptimizeMotherOf().

ReOptimizeMotherOf()

void G4RunManager::ReOptimizeMotherOf

(

G4VPhysicalVolume *

pPhys

)

Definition at line 1001 of file G4RunManager.cc.

{
  G4LogicalVolume* pMotherL = pPhys->GetMotherLogical();
  if(pMotherL != nullptr)
    ReOptimize(pMotherL);
}

References G4VPhysicalVolume::GetMotherLogical(), and ReOptimize().

RestoreRandomNumberStatus()

void G4RunManager::RestoreRandomNumberStatus ( const G4String &  fileN )

virtual

Definition at line 870 of file G4RunManager.cc.

{
  G4String fileNameWithDirectory;
  if(fileN.find("/") == std::string::npos)
  {
    fileNameWithDirectory = randomNumberStatusDir + fileN;
  }
  else
  {
    fileNameWithDirectory = fileN;
  }
 
  G4Random::restoreEngineStatus(fileNameWithDirectory);
  if(verboseLevel > 0)
    G4cout << "RandomNumberEngineStatus restored from file: "
           << fileNameWithDirectory << G4endl;
  G4Random::showEngineStatus();
}

References G4cout, G4endl, randomNumberStatusDir, and verboseLevel.

Referenced by export_G4RunManager(), and G4RunMessenger::SetNewValue().

RestoreRndmEachEvent()

virtual void G4RunManager::RestoreRndmEachEvent ( G4bool  )

inlinevirtual

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 346 of file G4RunManager.hh.

{ /* No effect in SEQ */ }

Referenced by G4RunMessenger::SetNewValue().

rndmSaveThisEvent()

void G4RunManager::rndmSaveThisEvent ( )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 831 of file G4RunManager.cc.

{
  if(currentEvent == 0)
  {
    G4cerr << "Warning from G4RunManager::rndmSaveThisEvent():"
           << " there is no currentEvent available." << G4endl
           << "Command ignored." << G4endl;
    return;
  }
 
  if(!storeRandomNumberStatus)
  {
    G4cerr << "Warning from G4RunManager::rndmSaveThisEvent():"
           << " Random number engine status is not available." << G4endl
           << "/random/setSavingFlag command must be issued "
           << "prior to the start of the run. Command ignored." << G4endl;
    return;
  }
 
  G4String fileIn = randomNumberStatusDir + "currentEvent.rndm";
 
  std::ostringstream os;
  os << "run" << currentRun->GetRunID() << "evt" << currentEvent->GetEventID()
     << ".rndm" << '\0';
  G4String fileOut = randomNumberStatusDir + os.str();
 
#ifdef WIN32
  G4String copCmd = "/control/shell copy " + fileIn + " " + fileOut;
#else
  G4String copCmd = "/control/shell cp " + fileIn + " " + fileOut;
#endif
  G4UImanager::GetUIpointer()->ApplyCommand(copCmd);
  if(verboseLevel > 0)
  {
    G4cout << fileIn << " is copied to " << fileOut << G4endl;
  }
}

References G4UImanager::ApplyCommand(), currentEvent, currentRun, G4cerr, G4cout, G4endl, G4Event::GetEventID(), G4Run::GetRunID(), G4UImanager::GetUIpointer(), randomNumberStatusDir, storeRandomNumberStatus, and verboseLevel.

Referenced by export_G4RunManager(), and G4RunMessenger::SetNewValue().

rndmSaveThisRun()

void G4RunManager::rndmSaveThisRun ( )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 798 of file G4RunManager.cc.

{
  G4int runNumber = 0;
  if(currentRun != nullptr)
    runNumber = currentRun->GetRunID();
  if(!storeRandomNumberStatus)
  {
    G4cerr << "Warning from G4RunManager::rndmSaveThisRun():"
           << " Random number status was not stored prior to this run."
           << G4endl << "/random/setSavingFlag command must be issued. "
           << "Command ignored." << G4endl;
    return;
  }
 
  G4String fileIn = randomNumberStatusDir + "currentRun.rndm";
 
  std::ostringstream os;
  os << "run" << runNumber << ".rndm" << '\0';
  G4String fileOut = randomNumberStatusDir + os.str();
 
#ifdef WIN32
  G4String copCmd = "/control/shell copy " + fileIn + " " + fileOut;
#else
  G4String copCmd = "/control/shell cp " + fileIn + " " + fileOut;
#endif
  G4UImanager::GetUIpointer()->ApplyCommand(copCmd);
  if(verboseLevel > 0)
  {
    G4cout << fileIn << " is copied to " << fileOut << G4endl;
  }
}

References G4UImanager::ApplyCommand(), currentRun, G4cerr, G4cout, G4endl, G4Run::GetRunID(), G4UImanager::GetUIpointer(), randomNumberStatusDir, storeRandomNumberStatus, and verboseLevel.

Referenced by export_G4RunManager(), and G4RunMessenger::SetNewValue().

RunInitialization()

void G4RunManager::RunInitialization ( )

virtual

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 332 of file G4RunManager.cc.

{
  if(!(kernel->RunInitialization(fakeRun)))
    return;
 
  runAborted             = false;
  numberOfEventProcessed = 0;
 
  CleanUpPreviousEvents();
  delete currentRun;
  currentRun = nullptr;
 
  if(fakeRun)
    return;
 
  if(fGeometryHasBeenDestroyed)
    G4ParallelWorldProcessStore::GetInstance()->UpdateWorlds();
 
  if(userRunAction != nullptr)
    currentRun = userRunAction->GenerateRun();
  if(currentRun == nullptr)
    currentRun = new G4Run();
 
  currentRun->SetRunID(runIDCounter);
  currentRun->SetNumberOfEventToBeProcessed(numberOfEventToBeProcessed);
 
  currentRun->SetDCtable(DCtable);
  G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
  if(fSDM != nullptr)
  {
    currentRun->SetHCtable(fSDM->GetHCtable());
  }
 
  if(G4VScoreNtupleWriter::Instance() != nullptr)
  {
    auto hce            = fSDM->PrepareNewEvent();
    isScoreNtupleWriter = G4VScoreNtupleWriter::Instance()->Book(hce);
    delete hce;
  }
 
  std::ostringstream oss;
  G4Random::saveFullState(oss);
  randomNumberStatusForThisRun = oss.str();
  currentRun->SetRandomNumberStatus(randomNumberStatusForThisRun);
 
  for(G4int i_prev = 0; i_prev < n_perviousEventsToBeStored; ++i_prev)
  {
    previousEvents->push_back(nullptr);
  }
 
  if(printModulo >= 0 || verboseLevel > 0)
  {
    G4cout << "### Run " << currentRun->GetRunID() << " starts." << G4endl;
  }
  if(userRunAction != nullptr)
    userRunAction->BeginOfRunAction(currentRun);
 
#if defined(GEANT4_USE_TIMEMORY)
  masterRunProfiler.reset(new ProfilerConfig(currentRun));
#endif
 
  if(isScoreNtupleWriter)
  {
    G4VScoreNtupleWriter::Instance()->OpenFile();
  }
 
  if(storeRandomNumberStatus)
  {
    G4String fileN = "currentRun";
    if(rngStatusEventsFlag)
    {
      std::ostringstream os;
      os << "run" << currentRun->GetRunID();
      fileN = os.str();
    }
    StoreRNGStatus(fileN);
  }
}

References G4UserRunAction::BeginOfRunAction(), G4VScoreNtupleWriter::Book(), CleanUpPreviousEvents(), currentRun, DCtable, fakeRun, fGeometryHasBeenDestroyed, G4cout, G4endl, G4UserRunAction::GenerateRun(), G4SDManager::GetHCtable(), G4ParallelWorldProcessStore::GetInstance(), G4Run::GetRunID(), G4SDManager::GetSDMpointerIfExist(), G4VScoreNtupleWriter::Instance(), isScoreNtupleWriter, kernel, masterRunProfiler, n_perviousEventsToBeStored, numberOfEventProcessed, numberOfEventToBeProcessed, G4VScoreNtupleWriter::OpenFile(), G4SDManager::PrepareNewEvent(), previousEvents, printModulo, randomNumberStatusForThisRun, rngStatusEventsFlag, runAborted, runIDCounter, G4RunManagerKernel::RunInitialization(), G4Run::SetDCtable(), G4Run::SetHCtable(), G4Run::SetNumberOfEventToBeProcessed(), G4Run::SetRandomNumberStatus(), G4Run::SetRunID(), storeRandomNumberStatus, StoreRNGStatus(), G4ParallelWorldProcessStore::UpdateWorlds(), userRunAction, and verboseLevel.

Referenced by BeamOn().

RunTermination()

void G4RunManager::RunTermination ( )

virtual

Reimplemented in G4MTRunManager, G4WorkerRunManager, G4TaskRunManager, and G4WorkerTaskRunManager.

Definition at line 558 of file G4RunManager.cc.

{
  if(!fakeRun)
  {
#if defined(GEANT4_USE_TIMEMORY)
    masterRunProfiler.reset();
#endif
    CleanUpUnnecessaryEvents(0);
    // tasking occasionally will call this function even
    // if there was not a current run
    if(currentRun != nullptr)
    {
      if(userRunAction != nullptr)
        userRunAction->EndOfRunAction(currentRun);
      G4VPersistencyManager* fPersM =
        G4VPersistencyManager::GetPersistencyManager();
      if(fPersM != nullptr)
        fPersM->Store(currentRun);
      // write & close analysis output
      if(isScoreNtupleWriter)
      {
        G4VScoreNtupleWriter::Instance()->Write();
      }
    }
    ++runIDCounter;
  }
 
  kernel->RunTermination();
}

References CleanUpUnnecessaryEvents(), currentRun, G4UserRunAction::EndOfRunAction(), fakeRun, G4VPersistencyManager::GetPersistencyManager(), G4VScoreNtupleWriter::Instance(), isScoreNtupleWriter, kernel, masterRunProfiler, runIDCounter, G4RunManagerKernel::RunTermination(), G4VPersistencyManager::Store(), userRunAction, and G4VScoreNtupleWriter::Write().

Referenced by BeamOn(), G4MTRunManager::RunTermination(), G4WorkerRunManager::RunTermination(), G4TaskRunManager::RunTermination(), and G4WorkerTaskRunManager::RunTermination().

SetDCtable()

void G4RunManager::SetDCtable ( G4DCtable *  DCtbl )

inline

Definition at line 573 of file G4RunManager.hh.

{ DCtable = DCtbl; }

References DCtable.

Referenced by G4DigiManager::AddNewModule().

SetGeometryToBeOptimized()

void G4RunManager::SetGeometryToBeOptimized ( G4bool  vl )

inline

Definition at line 317 of file G4RunManager.hh.

    {
      if(geometryToBeOptimized != vl)
      {
        geometryToBeOptimized = vl;
        kernel->GeometryHasBeenModified();
        kernel->SetGeometryToBeOptimized(vl);
      }
    }

References G4RunManagerKernel::GeometryHasBeenModified(), geometryToBeOptimized, kernel, and G4RunManagerKernel::SetGeometryToBeOptimized().

Referenced by G4RunMessenger::SetNewValue().

SetNumberOfAdditionalWaitingStacks()

void G4RunManager::SetNumberOfAdditionalWaitingStacks ( G4int  iAdd )

inline

Definition at line 422 of file G4RunManager.hh.

    {
      eventManager->SetNumberOfAdditionalWaitingStacks(iAdd);
    }

References eventManager, and G4EventManager::SetNumberOfAdditionalWaitingStacks().

SetNumberOfEventsToBeProcessed()

void G4RunManager::SetNumberOfEventsToBeProcessed ( G4int  val )

inline

Definition at line 563 of file G4RunManager.hh.

    {
      numberOfEventToBeProcessed = val;
    }

References numberOfEventToBeProcessed.

SetNumberOfEventsToBeStored()

void G4RunManager::SetNumberOfEventsToBeStored ( G4int  val )

inline

Definition at line 524 of file G4RunManager.hh.

    {
      n_perviousEventsToBeStored = val;
    }

References n_perviousEventsToBeStored.

SetNumberOfThreads()

virtual void G4RunManager::SetNumberOfThreads ( G4int  )

inlinevirtual

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 264 of file G4RunManager.hh.

{}

SetPrimaryTransformer()

void G4RunManager::SetPrimaryTransformer ( G4PrimaryTransformer *  pt )

inline

Definition at line 436 of file G4RunManager.hh.

    {
      kernel->SetPrimaryTransformer(pt);
    }

References kernel, and G4RunManagerKernel::SetPrimaryTransformer().

SetPrintProgress()

void G4RunManager::SetPrintProgress ( G4int  i )

inline

Definition at line 522 of file G4RunManager.hh.

{ printModulo = i; }

References printModulo.

Referenced by G4RunMessenger::SetNewValue().

SetRandomNumberStore()

void G4RunManager::SetRandomNumberStore ( G4bool  flag )

inline

Definition at line 456 of file G4RunManager.hh.

    {
      storeRandomNumberStatus = flag;
    }

References storeRandomNumberStatus.

Referenced by export_G4RunManager(), and G4RunMessenger::SetNewValue().

SetRandomNumberStoreDir()

void G4RunManager::SetRandomNumberStoreDir ( const G4String &  dir )

inline

Definition at line 464 of file G4RunManager.hh.

    {
      G4String dirStr = dir;
      if(dirStr.back() != '/')
        dirStr += "/";
    #ifndef WIN32
      G4String shellCmd = "mkdir -p ";
    #else
      std::replace(dirStr.begin(), dirStr.end(), '/', '\\');
      G4String shellCmd = "if not exist " + dirStr + " mkdir ";
    #endif
      shellCmd += dirStr;
      randomNumberStatusDir = dirStr;
      G4int sysret          = system(shellCmd);
      if(sysret != 0)
      {
        G4String errmsg = "\"" + shellCmd
                 + "\" returns non-zero value. Directory creation failed.";
        G4Exception("GrRunManager::SetRandomNumberStoreDir", "Run0071",
                    JustWarning, errmsg);
        G4cerr << " return value = " << sysret << G4endl;
      }
    }

References G4cerr, G4endl, G4Exception(), JustWarning, and randomNumberStatusDir.

Referenced by export_G4RunManager(), and G4RunMessenger::SetNewValue().

SetRandomNumberStorePerEvent()

void G4RunManager::SetRandomNumberStorePerEvent ( G4bool  flag )

inline

Definition at line 506 of file G4RunManager.hh.

    {
      rngStatusEventsFlag = flag;
    }

References rngStatusEventsFlag.

Referenced by G4RunMessenger::SetNewValue().

SetRunIDCounter()

void G4RunManager::SetRunIDCounter ( G4int  i )

inline

Definition at line 558 of file G4RunManager.hh.

{ runIDCounter = i; }

References runIDCounter.

Referenced by export_G4RunManager(), G4MTRunManager::Initialize(), and G4TaskRunManager::Initialize().

SetUserAction() [1/6]

void G4RunManager::SetUserAction ( G4UserEventAction *  userAction )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1089 of file G4RunManager.cc.

{
  eventManager->SetUserAction(userAction);
  userEventAction = userAction;
}

References eventManager, G4EventManager::SetUserAction(), and userEventAction.

SetUserAction() [2/6]

void G4RunManager::SetUserAction ( G4UserRunAction *  userAction )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1077 of file G4RunManager.cc.

{
  userRunAction = userAction;
}

References userRunAction.

Referenced by G4MTRunManager::SetUserAction(), G4WorkerRunManager::SetUserAction(), and G4VUserActionInitialization::SetUserAction().

SetUserAction() [3/6]

void G4RunManager::SetUserAction ( G4UserStackingAction *  userAction )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1096 of file G4RunManager.cc.

{
  eventManager->SetUserAction(userAction);
  userStackingAction = userAction;
}

References eventManager, G4EventManager::SetUserAction(), and userStackingAction.

SetUserAction() [4/6]

void G4RunManager::SetUserAction ( G4UserSteppingAction *  userAction )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1110 of file G4RunManager.cc.

{
  eventManager->SetUserAction(userAction);
  userSteppingAction = userAction;
}

References eventManager, G4EventManager::SetUserAction(), and userSteppingAction.

SetUserAction() [5/6]

void G4RunManager::SetUserAction ( G4UserTrackingAction *  userAction )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1103 of file G4RunManager.cc.

{
  eventManager->SetUserAction(userAction);
  userTrackingAction = userAction;
}

References eventManager, G4EventManager::SetUserAction(), and userTrackingAction.

SetUserAction() [6/6]

void G4RunManager::SetUserAction ( G4VUserPrimaryGeneratorAction *  userAction )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1083 of file G4RunManager.cc.

{
  userPrimaryGeneratorAction = userAction;
}

References userPrimaryGeneratorAction.

SetUserInitialization() [1/5]

void G4RunManager::SetUserInitialization ( G4UserWorkerInitialization *  userInit )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1050 of file G4RunManager.cc.

{
  G4Exception(
    "G4RunManager::SetUserInitialization()", "Run3001", FatalException,
    "Base-class G4RunManager cannot take G4UserWorkerInitialization. Use "
    "G4MTRunManager.");
}

References FatalException, and G4Exception().

SetUserInitialization() [2/5]

void G4RunManager::SetUserInitialization ( G4UserWorkerThreadInitialization *  userInit )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1060 of file G4RunManager.cc.

{
  G4Exception(
    "G4RunManager::SetUserThreadInitialization()", "Run3001", FatalException,
    "Base-class G4RunManager cannot take G4UserWorkerThreadInitialization. "
    "Use G4MTRunManager.");
}

References FatalException, and G4Exception().

SetUserInitialization() [3/5]

void G4RunManager::SetUserInitialization ( G4VUserActionInitialization *  userInit )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1070 of file G4RunManager.cc.

{
  userActionInitialization = userInit;
  userActionInitialization->Build();
}

References G4VUserActionInitialization::Build(), and userActionInitialization.

SetUserInitialization() [4/5]

void G4RunManager::SetUserInitialization ( G4VUserDetectorConstruction *  userInit )

virtual

Reimplemented in G4MTRunManager, and G4WorkerRunManager.

Definition at line 1037 of file G4RunManager.cc.

{
  userDetector = userInit;
}

References userDetector.

Referenced by G4WorkerRunManager::SetUserInitialization(), and G4MTRunManager::SetUserInitialization().

SetUserInitialization() [5/5]

void G4RunManager::SetUserInitialization ( G4VUserPhysicsList *  userInit )

virtual

Reimplemented in G4WorkerRunManager, and G4MTRunManager.

Definition at line 1043 of file G4RunManager.cc.

{
  physicsList = userInit;
  kernel->SetPhysics(userInit);
}

References kernel, physicsList, and G4RunManagerKernel::SetPhysics().

SetVerboseLevel()

void G4RunManager::SetVerboseLevel ( G4int  vl )

inline

Definition at line 515 of file G4RunManager.hh.

    {
      verboseLevel = vl;
      kernel->SetVerboseLevel(vl);
    }

References kernel, G4RunManagerKernel::SetVerboseLevel(), and verboseLevel.

Referenced by export_G4RunManager(), and G4RunMessenger::SetNewValue().

StackPreviousEvent()

void G4RunManager::StackPreviousEvent ( G4Event *  anEvent )

protected

Definition at line 646 of file G4RunManager.cc.

{
  if(anEvent->ToBeKept())
    currentRun->StoreEvent(anEvent);
 
  if(n_perviousEventsToBeStored == 0)
  {
    if(anEvent->GetNumberOfGrips() == 0)
    {
      if(!(anEvent->ToBeKept()))
        delete anEvent;
    }
    else
    {
      previousEvents->push_back(anEvent);
    }
  }
  CleanUpUnnecessaryEvents(n_perviousEventsToBeStored);
}

References CleanUpUnnecessaryEvents(), currentRun, G4Event::GetNumberOfGrips(), n_perviousEventsToBeStored, previousEvents, G4Run::StoreEvent(), and G4Event::ToBeKept().

Referenced by TerminateOneEvent().

StoreRandomNumberStatusToG4Event()

void G4RunManager::StoreRandomNumberStatusToG4Event ( G4int  vl )

inline

Definition at line 441 of file G4RunManager.hh.

    {
      storeRandomNumberStatusToG4Event = vl;
      eventManager->StoreRandomNumberStatusToG4Event(vl);
    }

References eventManager, G4EventManager::StoreRandomNumberStatusToG4Event(), and storeRandomNumberStatusToG4Event.

Referenced by G4RunMessenger::SetNewValue().

StoreRNGStatus()

void G4RunManager::StoreRNGStatus ( const G4String &  filenamePrefix )

protectedvirtual

Reimplemented in G4MTRunManager, G4WorkerRunManager, G4TaskRunManager, and G4WorkerTaskRunManager.

Definition at line 541 of file G4RunManager.cc.

{
  G4String fileN = randomNumberStatusDir + fnpref + ".rndm";
  G4Random::saveEngineStatus(fileN);
}

References randomNumberStatusDir.

Referenced by GenerateEvent(), and RunInitialization().

TerminateEventLoop()

void G4RunManager::TerminateEventLoop ( )

virtual

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 477 of file G4RunManager.cc.

{
  if(verboseLevel > 0 && !fakeRun)
  {
    timer->Stop();
    G4cout << " Run terminated." << G4endl;
    G4cout << "Run Summary" << G4endl;
    if(runAborted)
    {
      G4cout << "  Run Aborted after " << numberOfEventProcessed
             << " events processed." << G4endl;
    }
    else
    {
      G4cout << "  Number of events processed : " << numberOfEventProcessed
             << G4endl;
    }
    G4cout << "  " << *timer << G4endl;
  }
  fGeometryHasBeenDestroyed = false;
}

References fakeRun, fGeometryHasBeenDestroyed, G4cout, G4endl, numberOfEventProcessed, runAborted, G4Timer::Stop(), timer, and verboseLevel.

Referenced by DoEventLoop(), G4MTRunManager::RunTermination(), and G4TaskRunManager::RunTermination().

TerminateOneEvent()

void G4RunManager::TerminateOneEvent ( )

virtual

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 469 of file G4RunManager.cc.

{
  StackPreviousEvent(currentEvent);
  currentEvent = 0;
  ++numberOfEventProcessed;
}

References currentEvent, numberOfEventProcessed, and StackPreviousEvent().

Referenced by G4WorkerRunManager::DoEventLoop(), DoEventLoop(), and G4WorkerTaskRunManager::DoEventLoop().

UpdateScoring()

void G4RunManager::UpdateScoring ( )

protected

Definition at line 973 of file G4RunManager.cc.

{
  if(isScoreNtupleWriter)
  {
    G4VScoreNtupleWriter::Instance()->Fill(currentEvent->GetHCofThisEvent(),
                                           currentEvent->GetEventID());
  }
 
  G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
  if(ScM == nullptr)
    return;
  G4int nPar = ScM->GetNumberOfMesh();
  if(nPar < 1)
    return;
 
  G4HCofThisEvent* HCE = currentEvent->GetHCofThisEvent();
  if(HCE == nullptr)
    return;
  G4int nColl = HCE->GetCapacity();
  for(G4int i = 0; i < nColl; ++i)
  {
    G4VHitsCollection* HC = HCE->GetHC(i);
    if(HC != nullptr)
      ScM->Accumulate(HC);
  }
}

References G4ScoringManager::Accumulate(), currentEvent, G4VScoreNtupleWriter::Fill(), G4HCofThisEvent::GetCapacity(), G4Event::GetEventID(), G4HCofThisEvent::GetHC(), G4Event::GetHCofThisEvent(), G4ScoringManager::GetNumberOfMesh(), G4ScoringManager::GetScoringManagerIfExist(), G4VScoreNtupleWriter::Instance(), and isScoreNtupleWriter.

Referenced by ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), and G4WorkerTaskRunManager::ProcessOneEvent().

Friends And Related Function Documentation

G4RunManagerFactory

friend class G4RunManagerFactory

friend

Definition at line 139 of file G4RunManager.hh.

Field Documentation

currentEvent

G4Event* G4RunManager::currentEvent = nullptr

protected

Definition at line 631 of file G4RunManager.hh.

Referenced by AbortEvent(), AbortRun(), GetCurrentEvent(), ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), G4WorkerTaskRunManager::ProcessOneEvent(), rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), TerminateOneEvent(), and UpdateScoring().

currentRun

G4Run* G4RunManager::currentRun = nullptr

protected

Definition at line 630 of file G4RunManager.hh.

Referenced by AnalyzeEvent(), G4WorkerTaskRunManager::DoCleanup(), GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), GetCurrentRun(), GetNonConstCurrentRun(), G4WorkerRunManager::MergePartialResults(), G4MTRunManager::MergeRun(), G4TaskRunManager::MergeRun(), rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4MTRunManager::rndmSaveThisRun(), rndmSaveThisRun(), G4WorkerRunManager::rndmSaveThisRun(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), RunTermination(), G4WorkerTaskRunManager::RunTermination(), StackPreviousEvent(), and ~G4RunManager().

currentWorld

G4VPhysicalVolume* G4RunManager::currentWorld = nullptr

protected

Definition at line 643 of file G4RunManager.hh.

DCtable

G4DCtable* G4RunManager::DCtable = nullptr

protected

Definition at line 628 of file G4RunManager.hh.

Referenced by RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and SetDCtable().

eventManager

G4EventManager* G4RunManager::eventManager = nullptr

protected

Definition at line 604 of file G4RunManager.hh.

Referenced by AbortEvent(), AbortRun(), G4RunManager(), ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), G4WorkerTaskRunManager::ProcessOneEvent(), SetNumberOfAdditionalWaitingStacks(), SetUserAction(), and StoreRandomNumberStatusToG4Event().

fakeRun

G4bool G4RunManager::fakeRun = false

protected

Definition at line 651 of file G4RunManager.hh.

Referenced by BeamOn(), G4TaskRunManager::ComputeNumberOfTasks(), G4TaskRunManager::CreateAndStartWorkers(), G4MTRunManager::InitializeEventLoop(), G4TaskRunManager::InitializeEventLoop(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), RunTermination(), G4WorkerRunManager::RunTermination(), G4WorkerTaskRunManager::RunTermination(), TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), G4WorkerTaskRunManager::TerminateEventLoop(), G4TaskRunManager::TerminateWorkers(), and G4TaskRunManager::WaitForEndEventLoopWorkers().

fGeometryHasBeenDestroyed

G4bool G4RunManager::fGeometryHasBeenDestroyed = false

staticprotected

Definition at line 658 of file G4RunManager.hh.

Referenced by ConstructScoringWorlds(), G4WorkerRunManager::ConstructScoringWorlds(), IfGeometryHasBeenDestroyed(), G4WorkerRunManager::InitializeGeometry(), ReinitializeGeometry(), RunInitialization(), G4WorkerRunManager::RunInitialization(), and TerminateEventLoop().

fRunManager

G4ThreadLocal G4RunManager * G4RunManager::fRunManager = nullptr

staticprivate

Definition at line 663 of file G4RunManager.hh.

Referenced by G4RunManager(), GetRunManager(), and ~G4RunManager().

geometryDirectlyUpdated

G4bool G4RunManager::geometryDirectlyUpdated = false

protected

Definition at line 654 of file G4RunManager.hh.

Referenced by GeometryDirectlyUpdated(), and InitializeGeometry().

geometryInitialized

G4bool G4RunManager::geometryInitialized = false

protected

Definition at line 618 of file G4RunManager.hh.

Referenced by ConfirmBeamOnCondition(), Initialize(), InitializeGeometry(), G4WorkerRunManager::InitializeGeometry(), and ReinitializeGeometry().

geometryToBeOptimized

G4bool G4RunManager::geometryToBeOptimized = true

protected

Definition at line 622 of file G4RunManager.hh.

Referenced by GetGeometryToBeOptimized(), and SetGeometryToBeOptimized().

initializedAtLeastOnce

G4bool G4RunManager::initializedAtLeastOnce = false

protected

Definition at line 621 of file G4RunManager.hh.

Referenced by ConfirmBeamOnCondition(), and Initialize().

isScoreNtupleWriter

G4bool G4RunManager::isScoreNtupleWriter = false

protected

Definition at line 652 of file G4RunManager.hh.

Referenced by RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), RunTermination(), and UpdateScoring().

kernel

G4RunManagerKernel* G4RunManager::kernel = nullptr

protected

Definition at line 603 of file G4RunManager.hh.

Referenced by G4WorkerRunManager::ConstructScoringWorlds(), G4RunManagerFactory::CreateRunManager(), DefineWorldVolume(), DumpRegion(), G4MTRunManager::G4MTRunManager(), G4RunManager(), G4TaskRunManager::G4TaskRunManager(), GeometryHasBeenModified(), G4MTRunManager::GetMasterRunManagerKernel(), G4RunManagerFactory::GetMasterRunManagerKernel(), GetVersionString(), G4WorkerRunManager::GetWorkerRunManagerKernel(), G4WorkerTaskRunManager::GetWorkerRunManagerKernel(), InitializeGeometry(), G4WorkerRunManager::InitializeGeometry(), InitializePhysics(), PhysicsHasBeenModified(), ReinitializeGeometry(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), RunTermination(), SetGeometryToBeOptimized(), SetPrimaryTransformer(), SetUserInitialization(), SetVerboseLevel(), and ~G4RunManager().

masterRunProfiler

std::unique_ptr<ProfilerConfig> G4RunManager::masterRunProfiler

private

Definition at line 668 of file G4RunManager.hh.

Referenced by RunInitialization(), and RunTermination().

msgText

G4String G4RunManager::msgText = " "

protected

Definition at line 647 of file G4RunManager.hh.

Referenced by G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4TaskRunManager::InitializeEventLoop(), ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), and G4WorkerTaskRunManager::ProcessOneEvent().

n_perviousEventsToBeStored

G4int G4RunManager::n_perviousEventsToBeStored = 0

protected

Definition at line 633 of file G4RunManager.hh.

Referenced by GetPreviousEvent(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), SetNumberOfEventsToBeStored(), and StackPreviousEvent().

n_select_msg

G4int G4RunManager::n_select_msg = -1

protected

Definition at line 648 of file G4RunManager.hh.

Referenced by GetNumberOfSelectEvents(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4TaskRunManager::InitializeEventLoop(), ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), and G4WorkerTaskRunManager::ProcessOneEvent().

nParallelWorlds

G4int G4RunManager::nParallelWorlds = 0

protected

Definition at line 645 of file G4RunManager.hh.

Referenced by GetNumberOfParallelWorld(), and InitializeGeometry().

numberOfEventProcessed

G4int G4RunManager::numberOfEventProcessed = 0

protected

Definition at line 649 of file G4RunManager.hh.

Referenced by BeamOn(), G4MTRunManager::InitializeEventLoop(), G4TaskRunManager::InitializeEventLoop(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4TaskRunManager::SetUpAnEvent(), G4MTRunManager::SetUpAnEvent(), G4MTRunManager::SetUpNEvents(), G4TaskRunManager::SetUpNEvents(), TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), G4WorkerTaskRunManager::TerminateEventLoop(), and TerminateOneEvent().

numberOfEventToBeProcessed

G4int G4RunManager::numberOfEventToBeProcessed = 0

protected

Definition at line 634 of file G4RunManager.hh.

Referenced by BeamOn(), GetNumberOfEventsToBeProcessed(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and SetNumberOfEventsToBeProcessed().

physicsInitialized

G4bool G4RunManager::physicsInitialized = false

protected

Definition at line 619 of file G4RunManager.hh.

Referenced by ConfirmBeamOnCondition(), Initialize(), and InitializePhysics().

physicsList

G4VUserPhysicsList* G4RunManager::physicsList = nullptr

protected

Definition at line 607 of file G4RunManager.hh.

Referenced by DeleteUserInitializations(), GetUserPhysicsList(), InitializePhysics(), SetUserInitialization(), and G4WorkerRunManager::~G4WorkerRunManager().

previousEvents

std::list<G4Event*>* G4RunManager::previousEvents = nullptr

protected

Definition at line 632 of file G4RunManager.hh.

Referenced by CleanUpPreviousEvents(), CleanUpUnnecessaryEvents(), G4RunManager(), GetPreviousEvent(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), StackPreviousEvent(), and ~G4RunManager().

printModulo

G4int G4RunManager::printModulo = -1

protected

Definition at line 626 of file G4RunManager.hh.

Referenced by GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), GetPrintProgress(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and SetPrintProgress().

randomNumberStatusDir

G4String G4RunManager::randomNumberStatusDir = "./"

protected

Definition at line 638 of file G4RunManager.hh.

Referenced by G4RunManager(), GetRandomNumberStoreDir(), RestoreRandomNumberStatus(), rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4MTRunManager::rndmSaveThisRun(), rndmSaveThisRun(), G4WorkerRunManager::rndmSaveThisRun(), SetRandomNumberStoreDir(), G4MTRunManager::StoreRNGStatus(), StoreRNGStatus(), G4WorkerRunManager::StoreRNGStatus(), G4TaskRunManager::StoreRNGStatus(), and G4WorkerTaskRunManager::StoreRNGStatus().

randomNumberStatusForThisEvent

G4String G4RunManager::randomNumberStatusForThisEvent = ""

protected

Definition at line 640 of file G4RunManager.hh.

Referenced by G4RunManager(), GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), and GetRandomNumberStatusForThisEvent().

randomNumberStatusForThisRun

G4String G4RunManager::randomNumberStatusForThisRun = ""

protected

Definition at line 639 of file G4RunManager.hh.

Referenced by G4RunManager(), GetRandomNumberStatusForThisRun(), RunInitialization(), G4WorkerRunManager::RunInitialization(), and G4WorkerTaskRunManager::RunInitialization().

rngStatusEventsFlag

G4bool G4RunManager::rngStatusEventsFlag = false

protected

Definition at line 641 of file G4RunManager.hh.

Referenced by GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), GetRandomNumberStorePerEvent(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and SetRandomNumberStorePerEvent().

runAborted

G4bool G4RunManager::runAborted = false

protected

Definition at line 620 of file G4RunManager.hh.

Referenced by G4MTRunManager::AbortRun(), AbortRun(), G4TaskRunManager::AbortRun(), G4WorkerRunManager::DoEventLoop(), DoEventLoop(), G4WorkerTaskRunManager::DoEventLoop(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4MTRunManager::SetUpNEvents(), G4TaskRunManager::SetUpNEvents(), TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), and G4WorkerTaskRunManager::TerminateEventLoop().

runIDCounter

G4int G4RunManager::runIDCounter = 0

protected

Definition at line 624 of file G4RunManager.hh.

Referenced by RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), RunTermination(), and SetRunIDCounter().

runManagerType

RMType G4RunManager::runManagerType

protected

Definition at line 656 of file G4RunManager.hh.

Referenced by DoEventLoop(), G4RunManager(), and GetRunManagerType().

runMessenger

G4RunMessenger* G4RunManager::runMessenger = nullptr

private

Definition at line 666 of file G4RunManager.hh.

Referenced by G4RunManager(), and ~G4RunManager().

selectMacro

G4String G4RunManager::selectMacro = ""

protected

Definition at line 650 of file G4RunManager.hh.

Referenced by GetSelectMacro(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), and G4TaskRunManager::InitializeEventLoop().

storeRandomNumberStatus

G4bool G4RunManager::storeRandomNumberStatus = false

protected

Definition at line 636 of file G4RunManager.hh.

Referenced by GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), GetRandomNumberStore(), rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4MTRunManager::rndmSaveThisRun(), rndmSaveThisRun(), G4WorkerRunManager::rndmSaveThisRun(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and SetRandomNumberStore().

storeRandomNumberStatusToG4Event

G4int G4RunManager::storeRandomNumberStatusToG4Event = 0

protected

Definition at line 637 of file G4RunManager.hh.

Referenced by GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), GetFlagRandomNumberStatusToG4Event(), GetRandomNumberStatusForThisEvent(), and StoreRandomNumberStatusToG4Event().

timer

G4Timer* G4RunManager::timer = nullptr

protected

Definition at line 627 of file G4RunManager.hh.

Referenced by G4RunManager(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4TaskRunManager::InitializeEventLoop(), TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), G4WorkerTaskRunManager::TerminateEventLoop(), and ~G4RunManager().

userActionInitialization

G4VUserActionInitialization* G4RunManager::userActionInitialization = nullptr

protected

Definition at line 608 of file G4RunManager.hh.

Referenced by DeleteUserInitializations(), GetNonConstUserActionInitialization(), GetUserActionInitialization(), G4MTRunManager::SetUserInitialization(), SetUserInitialization(), and G4WorkerRunManager::~G4WorkerRunManager().

userDetector

G4VUserDetectorConstruction* G4RunManager::userDetector = nullptr

protected

Definition at line 606 of file G4RunManager.hh.

Referenced by DeleteUserInitializations(), GetUserDetectorConstruction(), InitializeGeometry(), G4WorkerRunManager::InitializeGeometry(), SetUserInitialization(), and G4WorkerRunManager::~G4WorkerRunManager().

userEventAction

G4UserEventAction* G4RunManager::userEventAction = nullptr

protected

Definition at line 613 of file G4RunManager.hh.

Referenced by GetUserEventAction(), and SetUserAction().

userPrimaryGeneratorAction

G4VUserPrimaryGeneratorAction* G4RunManager::userPrimaryGeneratorAction = nullptr

protected

Definition at line 612 of file G4RunManager.hh.

Referenced by G4WorkerRunManager::DoEventLoop(), G4WorkerTaskRunManager::DoEventLoop(), GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), GetUserPrimaryGeneratorAction(), SetUserAction(), and ~G4RunManager().

userRunAction

G4UserRunAction* G4RunManager::userRunAction = nullptr

protected

Definition at line 611 of file G4RunManager.hh.

Referenced by GetUserRunAction(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), RunTermination(), SetUserAction(), and ~G4RunManager().

userStackingAction

G4UserStackingAction* G4RunManager::userStackingAction = nullptr

protected

Definition at line 614 of file G4RunManager.hh.

Referenced by GetUserStackingAction(), and SetUserAction().

userSteppingAction

G4UserSteppingAction* G4RunManager::userSteppingAction = nullptr

protected

Definition at line 616 of file G4RunManager.hh.

Referenced by GetUserSteppingAction(), and SetUserAction().

userTrackingAction

G4UserTrackingAction* G4RunManager::userTrackingAction = nullptr

protected

Definition at line 615 of file G4RunManager.hh.

Referenced by GetUserTrackingAction(), and SetUserAction().

userWorkerInitialization

G4UserWorkerInitialization* G4RunManager::userWorkerInitialization = nullptr

protected

Definition at line 609 of file G4RunManager.hh.

Referenced by DeleteUserInitializations(), GetUserWorkerInitialization(), G4MTRunManager::SetUserInitialization(), and G4WorkerRunManager::~G4WorkerRunManager().

userWorkerThreadInitialization

G4UserWorkerThreadInitialization* G4RunManager::userWorkerThreadInitialization = nullptr

protected

Definition at line 610 of file G4RunManager.hh.

Referenced by G4MTRunManager::CreateAndStartWorkers(), DeleteUserInitializations(), GetUserWorkerThreadInitialization(), G4MTRunManager::InitializeEventLoop(), G4TaskRunManager::InitializeEventLoop(), G4MTRunManager::SetUserInitialization(), G4MTRunManager::TerminateWorkers(), and G4WorkerRunManager::~G4WorkerRunManager().

verboseLevel

G4int G4RunManager::verboseLevel = 0

protected

Definition at line 625 of file G4RunManager.hh.

Referenced by G4TaskRunManager::AddEventTask(), G4TaskRunManager::ComputeNumberOfTasks(), ConfirmBeamOnCondition(), G4MTRunManager::CreateAndStartWorkers(), DeleteUserInitializations(), G4MTRunManager::G4MTRunManager(), GetVerboseLevel(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4TaskRunManager::InitializeEventLoop(), InitializeGeometry(), G4TaskRunManager::InitializeThreadPool(), ReinitializeGeometry(), ReOptimize(), RestoreRandomNumberStatus(), rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4MTRunManager::rndmSaveThisRun(), rndmSaveThisRun(), G4WorkerRunManager::rndmSaveThisRun(), RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4TaskRunManager::SetNumberOfThreads(), SetVerboseLevel(), TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), G4WorkerTaskRunManager::TerminateEventLoop(), ~G4RunManager(), and G4WorkerRunManager::~G4WorkerRunManager().

---

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

• source/run/include/G4RunManager.hh
• source/run/src/G4RunManager.cc