#include <G4WorkerRunManager.hh>

Inheritance diagram for G4WorkerRunManager:

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 ()

void	CutOffHasBeenModified ()

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

virtual void	DoEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)

virtual void	DoWork ()

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=nullptr) const

	G4WorkerRunManager ()

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 ()

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 flag)

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	SetWorkerThread (G4WorkerThread *wc)

void	StoreRandomNumberStatusToG4Event (G4int vl)

virtual void	TerminateEventLoop ()

virtual void	TerminateOneEvent ()

	~G4WorkerRunManager ()

Static Public Member Functions
static G4RunManager *	GetRunManager ()

static G4WorkerRunManager *	GetWorkerRunManager ()

static G4WorkerRunManagerKernel *	GetWorkerRunManagerKernel ()

static G4bool	IfGeometryHasBeenDestroyed ()

Protected Member Functions
void	CleanUpPreviousEvents ()

void	CleanUpUnnecessaryEvents (G4int keepNEvents)

virtual void	ConstructScoringWorlds ()

virtual void	DeleteUserInitializations ()

virtual void	MergePartialResults ()

virtual void	rndmSaveThisEvent ()

virtual void	rndmSaveThisRun ()

void	StackPreviousEvent (G4Event *anEvent)

virtual void	StoreRNGStatus (const G4String &filenamePrefix)

void	UpdateScoring ()

Protected Attributes
G4Event *	currentEvent = nullptr

G4Run *	currentRun = nullptr

G4VPhysicalVolume *	currentWorld = nullptr

G4int	currEvID = -1

G4DCtable *	DCtable = nullptr

G4bool	eventLoopOnGoing = false

G4EventManager *	eventManager = nullptr

G4bool	fakeRun = false

G4bool	geometryDirectlyUpdated = false

G4bool	geometryInitialized = false

G4bool	geometryToBeOptimized = true

G4bool	initializedAtLeastOnce = false

G4bool	isScoreNtupleWriter = false

G4RunManagerKernel *	kernel = nullptr

G4int	luxury = -1

G4String	msgText = " "

G4int	n_perviousEventsToBeStored = 0

G4int	n_select_msg = -1

G4int	nevModulo = -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	readStatusFromFile = false

G4bool	rngStatusEventsFlag = false

G4bool	runAborted = false

G4int	runIDCounter = 0

G4bool	runIsSeeded = false

RMType	runManagerType

G4SeedsQueue	seedsQueue

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

G4WorkerThread *	workerContext = nullptr

Static Protected Attributes
static G4RUN_DLL G4bool	fGeometryHasBeenDestroyed = false

Private Member Functions
void	SetupDefaultRNGEngine ()

Private Attributes
std::unique_ptr< ProfilerConfig >	masterRunProfiler

G4RunMessenger *	runMessenger = nullptr

std::unique_ptr< ProfilerConfig >	workerRunProfiler

Static Private Attributes
static G4ThreadLocal G4RunManager *	fRunManager = nullptr

Detailed Description

Definition at line 48 of file G4WorkerRunManager.hh.

Member Typedef Documentation

◆ ProfilerConfig

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

Definition at line 52 of file G4WorkerRunManager.hh.

Member Enumeration Documentation

◆ RMType

enum G4RunManager::RMType

inherited

Enumerator
sequentialRM
masterRM
workerRM

Definition at line 575 of file G4RunManager.hh.

    {
      sequentialRM,
      masterRM,
      workerRM
    };

Constructor & Destructor Documentation

◆ G4WorkerRunManager()

G4WorkerRunManager::G4WorkerRunManager ( )

Definition at line 74 of file G4WorkerRunManager.cc.

  : G4RunManager(workerRM)
{
  // This constructor should never be called in non-multithreaded 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("G4WorkerRunManager::G4WorkerRunManager()", "Run0103",
              FatalException, msg);
#endif
  G4ParticleTable::GetParticleTable()->WorkerG4ParticleTable();
  G4ScoringManager* masterScM = G4MTRunManager::GetMasterScoringManager();
  if(masterScM != nullptr)
    G4ScoringManager::GetScoringManager();  // TLS instance for a worker
 
  // Properly initialise luxury level for Ranlux* engines...
  //
  if(dynamic_cast<const CLHEP::Ranlux64Engine*>(G4Random::getTheEngine()))
  {
    const CLHEP::Ranlux64Engine* theEngine =
      dynamic_cast<const CLHEP::Ranlux64Engine*>(G4Random::getTheEngine());
    luxury = theEngine->getLuxury();
  }
  else if(dynamic_cast<const CLHEP::RanluxEngine*>(G4Random::getTheEngine()))
  {
    const CLHEP::RanluxEngine* theEngine =
      dynamic_cast<const CLHEP::RanluxEngine*>(G4Random::getTheEngine());
    luxury = theEngine->getLuxury();
  }
 
  G4UImanager::GetUIpointer()->SetIgnoreCmdNotFound(true);
 
#ifdef G4MULTITHREADED
  G4VVisManager* pVVis = G4VVisManager::GetConcreteInstance();
  if(pVVis != nullptr)
  {
    pVVis->SetUpForAThread();
    visIsSetUp = true;
  }
#endif
}

References FatalException, G4Exception(), G4VVisManager::GetConcreteInstance(), CLHEP::Ranlux64Engine::getLuxury(), CLHEP::RanluxEngine::getLuxury(), G4MTRunManager::GetMasterScoringManager(), G4ParticleTable::GetParticleTable(), G4ScoringManager::GetScoringManager(), G4UImanager::GetUIpointer(), luxury, G4UImanager::SetIgnoreCmdNotFound(), and G4ParticleTable::WorkerG4ParticleTable().

◆ ~G4WorkerRunManager()

G4WorkerRunManager::~G4WorkerRunManager ( )

Definition at line 122 of file G4WorkerRunManager.cc.

{
  // Delete thread-local data process manager objects
  if(physicsList)
  {
    // physicsList->TerminateWorker();
    // physicsList->RemoveProcessManager();
  }
 
  // Put these pointers to zero: owned by master thread
  // If not to zero, the base class destructor will attempt to
  // delete them
  userDetector                   = nullptr;
  userWorkerInitialization       = nullptr;
  userWorkerThreadInitialization = nullptr;
  userActionInitialization       = nullptr;
  physicsList                    = nullptr;
  if(verboseLevel > 0)
    G4cout << "Destroying WorkerRunManager (" << this << ")" << G4endl;
}

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

Member Function Documentation

◆ AbortEvent()

void G4RunManager::AbortEvent ( )

virtualinherited

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(), G4RunManager::currentEvent, G4RunManager::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 )

virtualinherited

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(), G4RunManager::currentEvent, G4RunManager::eventManager, G4cerr, G4endl, G4State_EventProc, G4State_GeomClosed, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4RunManager::runAborted, and G4Event::SetEventAborted().

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

◆ AnalyzeEvent()

void G4RunManager::AnalyzeEvent ( G4Event * anEvent )

virtualinherited

Definition at line 548 of file G4RunManager.cc.

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

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

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

◆ BeamOn()

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

virtualinherited

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 G4RunManager::ConfirmBeamOnCondition(), G4RunManager::ConstructScoringWorlds(), G4RunManager::DoEventLoop(), G4RunManager::fakeRun, G4RunManager::numberOfEventProcessed, G4RunManager::numberOfEventToBeProcessed, G4RunManager::RunInitialization(), and G4RunManager::RunTermination().

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

◆ CleanUpPreviousEvents()

void G4RunManager::CleanUpPreviousEvents ( )

protectedinherited

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 G4RunManager::previousEvents, and G4Event::ToBeKept().

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

◆ CleanUpUnnecessaryEvents()

void G4RunManager::CleanUpUnnecessaryEvents ( G4int keepNEvents )

protectedinherited

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(), G4RunManager::previousEvents, and G4Event::ToBeKept().

Referenced by G4RunManager::RunTermination(), and G4RunManager::StackPreviousEvent().

◆ ConfigureProfilers() [1/2]

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

virtualinherited

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 G4RunManager::ConfigureProfilers(), and G4RunManager::G4RunManager().

◆ ConfigureProfilers() [2/2]

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

inherited

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 G4RunManager::ConfigureProfilers().

◆ ConfirmBeamOnCondition()

G4bool G4RunManager::ConfirmBeamOnCondition ( )

virtualinherited

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, G4RunManager::geometryInitialized, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4RunManager::Initialize(), G4RunManager::initializedAtLeastOnce, G4RunManager::physicsInitialized, and G4RunManager::verboseLevel.

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

◆ ConstructScoringWorlds()

void G4WorkerRunManager::ConstructScoringWorlds ( )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 539 of file G4WorkerRunManager.cc.

{
  using MeshShape = G4VScoringMesh::MeshShape;
 
  // Return if unnecessary
  G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
  if(ScM == nullptr)
    return;
  G4int nPar = ScM->GetNumberOfMesh();
  if(nPar < 1)
    return;
 
  // Update thread-local G4TransportationManager of all the world volumes
  kernel->WorkerUpdateWorldVolume();
 
  G4ScoringManager* masterScM = G4MTRunManager::GetMasterScoringManager();
 
  auto particleIterator = 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)
      {
        G4ExceptionDescription ed;
        ed << "Mesh name <" << ScM->GetWorldName(iw)
           << "> is not found in the master thread.";
        G4Exception("G4WorkerRunManager::ConstructScoringWorlds()", "RUN79001",
                    FatalException, ed);
      }
    }
    if(!(mesh->GetMeshElementLogical()))
    {
      G4AutoLock l(&ConstructScoringWorldsMutex);
      G4VScoringMesh* masterMesh = masterScM->GetMesh(iw);
      mesh->SetMeshElementLogical(masterMesh->GetMeshElementLogical());
      l.unlock();
 
      if(mesh->GetShape() != MeshShape::realWorldLogVol)
      {
        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));
 
          particleIterator->reset();
          while((*particleIterator)())
          {
            G4ParticleDefinition* particle = particleIterator->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);
            }  // if(pmanager)
          }    // while
        }
        theParallelWorldProcess->SetLayeredMaterialFlag(mesh->LayeredMassFlg());
      }
    }
    mesh->WorkerConstruct(pWorld);
  }
}

References G4ProcessManager::AddProcess(), anonymous_namespace{G4WorkerRunManager.cc}::ConstructScoringWorldsMutex, FatalException, G4RunManager::fGeometryHasBeenDestroyed, G4Exception(), G4VScoringMesh::GeometryHasBeenDestroyed(), G4ParticleTable::GetIterator(), G4MTRunManager::GetMasterScoringManager(), G4ScoringManager::GetMesh(), G4VScoringMesh::GetMeshElementLogical(), G4ScoringManager::GetNumberOfMesh(), G4VScoringMesh::GetParallelWorldProcess(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), G4ScoringManager::GetScoringManagerIfExist(), G4VScoringMesh::GetShape(), G4TransportationManager::GetTransportationManager(), G4ScoringManager::GetWorldName(), idxAlongStep, idxAtRest, idxPostStep, G4ParallelWorldProcess::IsAtRestRequired(), G4TransportationManager::IsWorldExisting(), G4RunManager::kernel, G4VScoringMesh::LayeredMassFlg(), G4ParallelWorldProcess::SetLayeredMaterialFlag(), G4VScoringMesh::SetMeshElementLogical(), G4ParallelWorldProcess::SetParallelWorld(), G4VScoringMesh::SetParallelWorldProcess(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToSecond(), G4TemplateAutoLock< _Mutex_t >::unlock(), G4VScoringMesh::WorkerConstruct(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

Referenced by G4WorkerTaskRunManager::DoWork().

◆ CutOffHasBeenModified()

void G4RunManager::CutOffHasBeenModified ( )

inlineinherited

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`
	)

virtualinherited

Definition at line 791 of file G4RunManager.cc.

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

References G4RunManagerKernel::DefineWorldVolume(), and G4RunManager::kernel.

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

◆ DeleteUserInitializations()

void G4RunManager::DeleteUserInitializations ( )

protectedvirtualinherited

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, G4RunManager::physicsList, G4RunManager::userActionInitialization, G4RunManager::userDetector, G4RunManager::userWorkerInitialization, G4RunManager::userWorkerThreadInitialization, and G4RunManager::verboseLevel.

Referenced by G4RunManager::~G4RunManager().

◆ DoEventLoop()

void G4WorkerRunManager::DoEventLoop	(	G4int	n_event,
		const char *	macroFile = `0`,
		G4int	n_select = `-1`
	)

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 275 of file G4WorkerRunManager.cc.

{
  if(userPrimaryGeneratorAction == nullptr)
  {
    G4Exception("G4RunManager::GenerateEvent()", "Run0032", FatalException,
                "G4VUserPrimaryGeneratorAction is not defined!");
  }
 
  // This is the same as in the sequential case, just the for-loop indexes are
  // different
  InitializeEventLoop(n_event, macroFile, n_select);
 
  // Reset random number seeds queue
  while(seedsQueue.size() > 0)
  {
    seedsQueue.pop();
  }
  // for each run, worker should receive at least one set of random number
  // seeds.
  runIsSeeded = false;
 
  // Event loop
  eventLoopOnGoing = true;
  G4int i_event = -1;
  nevModulo     = -1;
  currEvID      = -1;
 
  while(eventLoopOnGoing)
  {
    ProcessOneEvent(i_event);
    if(eventLoopOnGoing)
    {
      TerminateOneEvent();
      if(runAborted)
      {
        eventLoopOnGoing = false;
      }
    }
  }
 
  TerminateEventLoop();
}

References currEvID, eventLoopOnGoing, FatalException, G4Exception(), G4RunManager::InitializeEventLoop(), nevModulo, ProcessOneEvent(), G4RunManager::runAborted, runIsSeeded, seedsQueue, TerminateEventLoop(), G4RunManager::TerminateOneEvent(), and G4RunManager::userPrimaryGeneratorAction.

◆ DoWork()

void G4WorkerRunManager::DoWork ( )

virtual

Reimplemented in G4WorkerTaskRunManager.

Definition at line 810 of file G4WorkerRunManager.cc.

{
  G4MTRunManager* mrm = G4MTRunManager::GetMasterRunManager();
  G4MTRunManager::WorkerActionRequest nextAction =
    mrm->ThisWorkerWaitForNextAction();
  while(nextAction != G4MTRunManager::WorkerActionRequest::ENDWORKER)
  {
    if(nextAction ==
       G4MTRunManager::WorkerActionRequest::NEXTITERATION)  // start the next
                                                            // run
    {
      // The following code deals with changing materials between runs
      static G4ThreadLocal G4bool skipInitialization = true;
      if(skipInitialization)
      {
        // re-initialization is not necessary for the first run
        skipInitialization = false;
      }
      else
      {
        //        ReinitializeGeometry();
        workerContext->UpdateGeometryAndPhysicsVectorFromMaster();
      }
 
      // Execute UI commands stored in the master UI manager
      std::vector<G4String> cmds = mrm->GetCommandStack();
      G4UImanager* uimgr         = G4UImanager::GetUIpointer(); // TLS instance
      for(auto it = cmds.cbegin(); it != cmds.cend(); ++it)
      {
        uimgr->ApplyCommand(*it);
      }
      // Start this run
      G4int numevents    = mrm->GetNumberOfEventsToBeProcessed();
      G4String macroFile = mrm->GetSelectMacro();
      G4int numSelect    = mrm->GetNumberOfSelectEvents();
      if(macroFile == "" || macroFile == " ")
      {
        this->BeamOn(numevents);
      }
      else
      {
        this->BeamOn(numevents, macroFile, numSelect);
      }
    }
    else if(nextAction == G4MTRunManager::WorkerActionRequest::PROCESSUI)
    {
      std::vector<G4String> cmds = mrm->GetCommandStack();
      G4UImanager* uimgr         = G4UImanager::GetUIpointer(); // TLS instance
      for(auto it = cmds.cbegin(); it != cmds.cend(); ++it)
      {
        uimgr->ApplyCommand(*it);
      }
      mrm->ThisWorkerProcessCommandsStackDone();
    }
    else
    {
      G4ExceptionDescription d;
      d << "Cannot continue, this worker has been requested an unknown action: "
        << static_cast<
             std::underlying_type<G4MTRunManager::WorkerActionRequest>::type>(
             nextAction);
      G4Exception("G4WorkerRunManager::DoWork", "Run0104", FatalException, d);
    }
 
    // Now wait for master thread to signal new action to be performed
    nextAction = mrm->ThisWorkerWaitForNextAction();
  }  // No more actions to perform
 
  return;
}

References G4UImanager::ApplyCommand(), G4RunManager::BeamOn(), G4MTRunManager::ENDWORKER, FatalException, G4Exception(), G4ThreadLocal, G4MTRunManager::GetCommandStack(), G4MTRunManager::GetMasterRunManager(), G4RunManager::GetNumberOfEventsToBeProcessed(), G4RunManager::GetNumberOfSelectEvents(), G4RunManager::GetSelectMacro(), G4UImanager::GetUIpointer(), G4MTRunManager::NEXTITERATION, G4MTRunManager::PROCESSUI, G4MTRunManager::ThisWorkerProcessCommandsStackDone(), G4MTRunManager::ThisWorkerWaitForNextAction(), G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster(), and workerContext.

Referenced by G4MTRunManagerKernel::StartThread().

◆ DumpRegion() [1/2]

void G4RunManager::DumpRegion ( const G4String & rname ) const

inherited

Definition at line 890 of file G4RunManager.cc.

{
  kernel->DumpRegion(rname);
}

References G4RunManagerKernel::DumpRegion(), and G4RunManager::kernel.

Referenced by G4RunMessenger::SetNewValue().

◆ DumpRegion() [2/2]

void G4RunManager::DumpRegion ( G4Region * region = nullptr ) const

inherited

Definition at line 896 of file G4RunManager.cc.

{
  kernel->DumpRegion(region);
}

References G4RunManagerKernel::DumpRegion(), and G4RunManager::kernel.

◆ GenerateEvent()

G4Event * G4WorkerRunManager::GenerateEvent ( G4int i_event )

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 340 of file G4WorkerRunManager.cc.

{
  G4Event* anEvent          = new G4Event(i_event);
  G4long s1                   = 0;
  G4long s2                   = 0;
  G4long s3                   = 0;
  G4bool eventHasToBeSeeded = true;
  if(G4MTRunManager::SeedOncePerCommunication() == 1 && runIsSeeded)
  {
    eventHasToBeSeeded = false;
  }
 
  if(i_event < 0)
  {
    G4int nevM = G4MTRunManager::GetMasterRunManager()->GetEventModulo();
    if(nevM == 1)
    {
      eventLoopOnGoing = G4MTRunManager::GetMasterRunManager()->SetUpAnEvent(
        anEvent, s1, s2, s3, eventHasToBeSeeded);
      runIsSeeded = true;
    }
    else
    {
      if(nevModulo <= 0)
      {
        G4int nevToDo = G4MTRunManager::GetMasterRunManager()->SetUpNEvents(
          anEvent, &seedsQueue, eventHasToBeSeeded);
        if(nevToDo == 0)
        {
          eventLoopOnGoing = false;
        }
        else
        {
          currEvID  = anEvent->GetEventID();
          nevModulo = nevToDo - 1;
        }
      }
      else
      {
        if(G4MTRunManager::SeedOncePerCommunication() > 0)
          eventHasToBeSeeded = false;
        anEvent->SetEventID(++currEvID);
        --nevModulo;
      }
      if(eventLoopOnGoing && eventHasToBeSeeded)
      {
        s1 = seedsQueue.front();
        seedsQueue.pop();
        s2 = seedsQueue.front();
        seedsQueue.pop();
      }
    }
 
    if(!eventLoopOnGoing)
    {
      delete anEvent;
      return nullptr;
    }
  }
  else if(eventHasToBeSeeded)
  {
    // Need to reseed random number generator
    G4RNGHelper* helper = G4RNGHelper::GetInstance();
    s1                  = helper->GetSeed(i_event * 2);
    s2                  = helper->GetSeed(i_event * 2 + 1);
  }
 
  if(eventHasToBeSeeded)
  {
    G4long seeds[3] = { s1, s2, 0 };
    G4Random::setTheSeeds(seeds, luxury);
    runIsSeeded = true;
  }
 
  // Read from file seed.
  // Andrea Dotti 4 November 2015
  // This is required for strong-reproducibility, in MT mode we have that each
  // thread produces, for each event a status file, we want to do that.
  // Search a random file with the format run{%d}evt{%d}.rndm
 
  // This is the filename base constructed from run and event
  const auto filename = [&] {
    std::ostringstream os;
    os << "run" << currentRun->GetRunID() << "evt" << anEvent->GetEventID();
    return os.str();
  };
 
  G4bool RNGstatusReadFromFile = false;
  if(readStatusFromFile)
  {
    // Build full path of RNG status file for this event
    std::ostringstream os;
    os << filename() << ".rndm";
    const G4String& randomStatusFile = os.str();
    std::ifstream ifile(randomStatusFile.c_str());
    if(ifile)
    {  // File valid and readable
      RNGstatusReadFromFile = true;
      G4Random::restoreEngineStatus(randomStatusFile.c_str());
    }
  }
 
  if(storeRandomNumberStatusToG4Event == 1 ||
     storeRandomNumberStatusToG4Event == 3)
  {
    std::ostringstream oss;
    G4Random::saveFullState(oss);
    randomNumberStatusForThisEvent = oss.str();
    anEvent->SetRandomNumberStatus(randomNumberStatusForThisEvent);
  }
 
  if(storeRandomNumberStatus && !RNGstatusReadFromFile)
  {  // If reading from file, avoid to rewrite the same
    G4String fileN = "currentEvent";
    if(rngStatusEventsFlag)
    {
      fileN = filename();
    }
    StoreRNGStatus(fileN);
  }
 
  if(printModulo > 0 && anEvent->GetEventID() % printModulo == 0)
  {
    G4cout << "--> Event " << anEvent->GetEventID() << " starts";
    if(eventHasToBeSeeded)
    {
      G4cout << " with initial seeds (" << s1 << "," << s2 << ")";
    }
    G4cout << "." << G4endl;
  }
  userPrimaryGeneratorAction->GeneratePrimaries(anEvent);
  return anEvent;
}

References G4RunManager::currentRun, currEvID, eventLoopOnGoing, G4cout, G4endl, G4VUserPrimaryGeneratorAction::GeneratePrimaries(), G4Event::GetEventID(), G4MTRunManager::GetEventModulo(), G4TemplateRNGHelper< T >::GetInstance(), G4MTRunManager::GetMasterRunManager(), G4Run::GetRunID(), G4TemplateRNGHelper< T >::GetSeed(), luxury, nevModulo, G4RunManager::printModulo, G4RunManager::randomNumberStatusForThisEvent, readStatusFromFile, G4RunManager::rngStatusEventsFlag, runIsSeeded, G4MTRunManager::SeedOncePerCommunication(), seedsQueue, G4Event::SetEventID(), G4Event::SetRandomNumberStatus(), G4MTRunManager::SetUpAnEvent(), G4MTRunManager::SetUpNEvents(), G4RunManager::storeRandomNumberStatus, G4RunManager::storeRandomNumberStatusToG4Event, StoreRNGStatus(), and G4RunManager::userPrimaryGeneratorAction.

Referenced by ProcessOneEvent().

◆ GeometryDirectlyUpdated()

void G4RunManager::GeometryDirectlyUpdated ( G4bool val = true )

inlineinherited

Definition at line 331 of file G4RunManager.hh.

    {
      geometryDirectlyUpdated = val;
    }

References G4RunManager::geometryDirectlyUpdated.

Referenced by G4GDMLMessenger::SetNewValue().

◆ GeometryHasBeenModified()

void G4RunManager::GeometryHasBeenModified ( G4bool prop = true )

inherited

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 G4RunManager::kernel.

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

◆ GetCurrentEvent()

const G4Event * G4RunManager::GetCurrentEvent ( ) const

inlineinherited

Definition at line 537 of file G4RunManager.hh.

537{ return currentEvent; }

References G4RunManager::currentEvent.

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

◆ GetCurrentRun()

const G4Run * G4RunManager::GetCurrentRun ( ) const

inlineinherited

Definition at line 533 of file G4RunManager.hh.

533{ return currentRun; }

References G4RunManager::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

inlineinherited

Definition at line 451 of file G4RunManager.hh.

    {
      return storeRandomNumberStatusToG4Event;
    }

References G4RunManager::storeRandomNumberStatusToG4Event.

Referenced by G4RunMessenger::GetCurrentValue().

◆ GetGeometryToBeOptimized()

G4bool G4RunManager::GetGeometryToBeOptimized ( )

inlineinherited

Definition at line 326 of file G4RunManager.hh.

    {
      return geometryToBeOptimized;
    }

References G4RunManager::geometryToBeOptimized.

Referenced by export_G4RunManager().

◆ GetNonConstCurrentRun()

G4Run * G4RunManager::GetNonConstCurrentRun ( ) const

inlineinherited

Definition at line 534 of file G4RunManager.hh.

534{ return currentRun; }

References G4RunManager::currentRun.

◆ GetNonConstUserActionInitialization()

G4VUserActionInitialization * G4RunManager::GetNonConstUserActionInitialization ( ) const

inlineinherited

Definition at line 384 of file G4RunManager.hh.

    {
      return userActionInitialization;
    }

References G4RunManager::userActionInitialization.

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

◆ GetNumberOfEventsToBeProcessed()

G4int G4RunManager::GetNumberOfEventsToBeProcessed ( ) const

inlineinherited

Definition at line 567 of file G4RunManager.hh.

    {
      return numberOfEventToBeProcessed;
    }

References G4RunManager::numberOfEventToBeProcessed.

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

◆ GetNumberOfParallelWorld()

G4int G4RunManager::GetNumberOfParallelWorld ( ) const

inlineinherited

Definition at line 562 of file G4RunManager.hh.

562{ return nParallelWorlds; }

G4RunManager::nParallelWorlds

G4int nParallelWorlds

Definition: G4RunManager.hh:645

References G4RunManager::nParallelWorlds.

◆ GetNumberOfSelectEvents()

G4int G4RunManager::GetNumberOfSelectEvents ( ) const

inlineinherited

Definition at line 571 of file G4RunManager.hh.

571{ return n_select_msg; }

G4RunManager::n_select_msg

G4int n_select_msg

Definition: G4RunManager.hh:648

References G4RunManager::n_select_msg.

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

◆ GetNumberOfThreads()

virtual G4int G4RunManager::GetNumberOfThreads ( ) const

inlinevirtualinherited

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 265 of file G4RunManager.hh.

265{ return 1; }

◆ GetPreviousEvent()

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

inlineinherited

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 G4RunManager::n_perviousEventsToBeStored, and G4RunManager::previousEvents.

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

◆ GetPrintProgress()

G4int G4RunManager::GetPrintProgress ( )

inlineinherited

Definition at line 521 of file G4RunManager.hh.

521{ return printModulo; }

References G4RunManager::printModulo.

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

◆ GetRandomNumberStatusForThisEvent()

const G4String & G4RunManager::GetRandomNumberStatusForThisEvent ( ) const

inlineinherited

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, G4RunManager::randomNumberStatusForThisEvent, and G4RunManager::storeRandomNumberStatusToG4Event.

◆ GetRandomNumberStatusForThisRun()

const G4String & G4RunManager::GetRandomNumberStatusForThisRun ( ) const

inlineinherited

Definition at line 491 of file G4RunManager.hh.

    {
      return randomNumberStatusForThisRun;
    }

References G4RunManager::randomNumberStatusForThisRun.

◆ GetRandomNumberStore()

G4bool G4RunManager::GetRandomNumberStore ( ) const

inlineinherited

Definition at line 460 of file G4RunManager.hh.

    {
      return storeRandomNumberStatus;
    }

References G4RunManager::storeRandomNumberStatus.

Referenced by export_G4RunManager().

◆ GetRandomNumberStoreDir()

const G4String & G4RunManager::GetRandomNumberStoreDir ( ) const

inlineinherited

Definition at line 487 of file G4RunManager.hh.

    {
      return randomNumberStatusDir;
    }

References G4RunManager::randomNumberStatusDir.

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

◆ GetRandomNumberStorePerEvent()

G4bool G4RunManager::GetRandomNumberStorePerEvent ( ) const

inlineinherited

Definition at line 510 of file G4RunManager.hh.

    {
      return rngStatusEventsFlag;
    }

References G4RunManager::rngStatusEventsFlag.

◆ GetRunManager()

G4RunManager * G4RunManager::GetRunManager ( )

staticinherited

Definition at line 111 of file G4RunManager.cc.

{
  return fRunManager;
}

References G4RunManager::fRunManager.

◆ GetRunManagerType()

RMType G4RunManager::GetRunManagerType ( ) const

inlineinherited

Definition at line 582 of file G4RunManager.hh.

582{ return runManagerType; }

G4RunManager::runManagerType

RMType runManagerType

Definition: G4RunManager.hh:656

References G4RunManager::runManagerType.

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

◆ GetSelectMacro()

const G4String & G4RunManager::GetSelectMacro ( ) const

inlineinherited

Definition at line 572 of file G4RunManager.hh.

572{ return selectMacro; }

G4RunManager::selectMacro

G4String selectMacro

Definition: G4RunManager.hh:650

References G4RunManager::selectMacro.

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

◆ GetUserActionInitialization()

const G4VUserActionInitialization * G4RunManager::GetUserActionInitialization ( ) const

inlineinherited

Definition at line 380 of file G4RunManager.hh.

    {
      return userActionInitialization;
    }

References G4RunManager::userActionInitialization.

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

◆ GetUserDetectorConstruction()

const G4VUserDetectorConstruction * G4RunManager::GetUserDetectorConstruction ( ) const

inlineinherited

Definition at line 372 of file G4RunManager.hh.

    {
      return userDetector;
    }

References G4RunManager::userDetector.

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

◆ GetUserEventAction()

const G4UserEventAction * G4RunManager::GetUserEventAction ( ) const

inlineinherited

Definition at line 404 of file G4RunManager.hh.

    {
      return userEventAction;
    }

References G4RunManager::userEventAction.

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

◆ GetUserPhysicsList()

const G4VUserPhysicsList * G4RunManager::GetUserPhysicsList ( ) const

inlineinherited

Definition at line 376 of file G4RunManager.hh.

    {
      return physicsList;
    }

References G4RunManager::physicsList.

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

◆ GetUserPrimaryGeneratorAction()

const G4VUserPrimaryGeneratorAction * G4RunManager::GetUserPrimaryGeneratorAction ( ) const

inlineinherited

Definition at line 400 of file G4RunManager.hh.

    {
      return userPrimaryGeneratorAction;
    }

References G4RunManager::userPrimaryGeneratorAction.

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

◆ GetUserRunAction()

const G4UserRunAction * G4RunManager::GetUserRunAction ( ) const

inlineinherited

Definition at line 396 of file G4RunManager.hh.

    {
      return userRunAction;
    }

References G4RunManager::userRunAction.

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

◆ GetUserStackingAction()

const G4UserStackingAction * G4RunManager::GetUserStackingAction ( ) const

inlineinherited

Definition at line 408 of file G4RunManager.hh.

    {
      return userStackingAction;
    }

References G4RunManager::userStackingAction.

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

◆ GetUserSteppingAction()

const G4UserSteppingAction * G4RunManager::GetUserSteppingAction ( ) const

inlineinherited

Definition at line 416 of file G4RunManager.hh.

    {
      return userSteppingAction;
    }

References G4RunManager::userSteppingAction.

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

◆ GetUserTrackingAction()

const G4UserTrackingAction * G4RunManager::GetUserTrackingAction ( ) const

inlineinherited

Definition at line 412 of file G4RunManager.hh.

    {
      return userTrackingAction;
    }

References G4RunManager::userTrackingAction.

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

◆ GetUserWorkerInitialization()

const G4UserWorkerInitialization * G4RunManager::GetUserWorkerInitialization ( ) const

inlineinherited

Definition at line 388 of file G4RunManager.hh.

    {
      return userWorkerInitialization;
    }

References G4RunManager::userWorkerInitialization.

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

◆ GetUserWorkerThreadInitialization()

const G4UserWorkerThreadInitialization * G4RunManager::GetUserWorkerThreadInitialization ( ) const

inlineinherited

Definition at line 392 of file G4RunManager.hh.

    {
      return userWorkerThreadInitialization;
    }

References G4RunManager::userWorkerThreadInitialization.

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

◆ GetVerboseLevel()

G4int G4RunManager::GetVerboseLevel ( ) const

inlineinherited

Definition at line 520 of file G4RunManager.hh.

520{ return verboseLevel; }

References G4RunManager::verboseLevel.

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

◆ GetVersionString()

const G4String & G4RunManager::GetVersionString ( ) const

inlineinherited

Definition at line 431 of file G4RunManager.hh.

    {
      return kernel->GetVersionString();
    }

References G4RunManagerKernel::GetVersionString(), and G4RunManager::kernel.

Referenced by export_G4RunManager().

◆ GetWorkerRunManager()

G4WorkerRunManager * G4WorkerRunManager::GetWorkerRunManager ( )

static

Definition at line 62 of file G4WorkerRunManager.cc.

{
  return static_cast<G4WorkerRunManager*>(G4RunManager::GetRunManager());
}

References G4RunManager::GetRunManager().

Referenced by GetWorkerRunManagerKernel(), G4RTWorkerInitialization::WorkerRunEnd(), and G4RTWorkerInitialization::WorkerRunStart().

◆ GetWorkerRunManagerKernel()

G4WorkerRunManagerKernel * G4WorkerRunManager::GetWorkerRunManagerKernel ( )

static

Definition at line 68 of file G4WorkerRunManager.cc.

{
  return static_cast<G4WorkerRunManagerKernel*>(GetWorkerRunManager()->kernel);
}

References GetWorkerRunManager(), and G4RunManager::kernel.

◆ IfGeometryHasBeenDestroyed()

G4bool G4RunManager::IfGeometryHasBeenDestroyed ( )

staticinherited

Definition at line 105 of file G4RunManager.cc.

{
  return fGeometryHasBeenDestroyed;
}

References G4RunManager::fGeometryHasBeenDestroyed.

Referenced by G4WorkerTaskRunManager::RunInitialization().

◆ Initialize()

void G4RunManager::Initialize ( void )

virtualinherited

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, G4RunManager::geometryInitialized, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4RunManager::initializedAtLeastOnce, G4RunManager::InitializeGeometry(), G4RunManager::InitializePhysics(), G4RunManager::physicsInitialized, and G4StateManager::SetNewState().

Referenced by G4RunManager::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`
	)

virtualinherited

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 G4RunManager::msgText, G4RunManager::n_select_msg, G4RunManager::selectMacro, G4Timer::Start(), G4RunManager::timer, and G4RunManager::verboseLevel.

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

◆ InitializeGeometry()

void G4WorkerRunManager::InitializeGeometry ( )

virtual

Reimplemented from G4RunManager.

Definition at line 144 of file G4WorkerRunManager.cc.

{
  if(userDetector == nullptr)
  {
    G4Exception("G4RunManager::InitializeGeometry", "Run0033", FatalException,
                "G4VUserDetectorConstruction is not defined!");
    return;
  }
  if(fGeometryHasBeenDestroyed)
  {
    G4TransportationManager::GetTransportationManager()->ClearParallelWorlds();
  }
 
  // Step1: Get pointer to the physiWorld (note: needs to get the "super
  // pointer, i.e. the one shared by all threads"
  G4RunManagerKernel* masterKernel =
    G4MTRunManager::GetMasterRunManagerKernel();
  G4VPhysicalVolume* worldVol = masterKernel->GetCurrentWorld();
  // Step2:, Call a new "WorkerDefineWorldVolume( pointer from 2-, false);
  kernel->WorkerDefineWorldVolume(worldVol, false);
  kernel->SetNumberOfParallelWorld(masterKernel->GetNumberOfParallelWorld());
  // Step3: Call user's ConstructSDandField()
  userDetector->ConstructSDandField();
  userDetector->ConstructParallelSD();
  geometryInitialized = true;
}

References G4TransportationManager::ClearParallelWorlds(), G4VUserDetectorConstruction::ConstructParallelSD(), G4VUserDetectorConstruction::ConstructSDandField(), FatalException, G4RunManager::fGeometryHasBeenDestroyed, G4Exception(), G4RunManager::geometryInitialized, G4RunManagerKernel::GetCurrentWorld(), G4MTRunManager::GetMasterRunManagerKernel(), G4RunManagerKernel::GetNumberOfParallelWorld(), G4TransportationManager::GetTransportationManager(), G4RunManager::kernel, G4RunManagerKernel::SetNumberOfParallelWorld(), G4RunManager::userDetector, and G4RunManagerKernel::WorkerDefineWorldVolume().

◆ InitializePhysics()

void G4RunManager::InitializePhysics ( )

virtualinherited

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(), G4RunManager::kernel, G4RunManager::physicsInitialized, G4RunManager::physicsList, and G4StateManager::SetNewState().

Referenced by G4RunManager::Initialize().

◆ MergePartialResults()

void G4WorkerRunManager::MergePartialResults ( )

protectedvirtual

Definition at line 475 of file G4WorkerRunManager.cc.

{
  // Merge partial results into global run
  G4MTRunManager* mtRM  = G4MTRunManager::GetMasterRunManager();
  G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
  if(ScM != nullptr)
    mtRM->MergeScores(ScM);
  mtRM->MergeRun(currentRun);
}

References G4RunManager::currentRun, G4MTRunManager::GetMasterRunManager(), G4ScoringManager::GetScoringManagerIfExist(), G4MTRunManager::MergeRun(), and G4MTRunManager::MergeScores().

Referenced by RunTermination(), and G4WorkerTaskRunManager::RunTermination().

◆ PhysicsHasBeenModified()

void G4RunManager::PhysicsHasBeenModified ( )

inlineinherited

Definition at line 294 of file G4RunManager.hh.

294{ kernel->PhysicsHasBeenModified(); }

G4RunManagerKernel::PhysicsHasBeenModified

void PhysicsHasBeenModified()

Definition: G4RunManagerKernel.hh:124

References G4RunManager::kernel, and G4RunManagerKernel::PhysicsHasBeenModified().

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

◆ ProcessOneEvent()

void G4WorkerRunManager::ProcessOneEvent ( G4int i_event )

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 326 of file G4WorkerRunManager.cc.

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

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

Referenced by DoEventLoop().

◆ ReinitializeGeometry()

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

inherited

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(), G4RunManager::fGeometryHasBeenDestroyed, G4cout, G4endl, G4RunManagerKernel::GeometryHasBeenModified(), G4VVisManager::GeometryHasChanged(), G4RunManager::geometryInitialized, G4VVisManager::GetConcreteInstance(), G4GeometryManager::GetInstance(), G4LogicalVolumeStore::GetInstance(), G4PhysicalVolumeStore::GetInstance(), G4RegionStore::GetInstance(), G4SolidStore::GetInstance(), G4AssemblyStore::GetInstance(), G4TransportationManager::GetTransportationManager(), G4UImanager::GetUIpointer(), G4Threading::IsMasterThread(), G4RunManager::kernel, G4GeometryManager::OpenGeometry(), and G4RunManager::verboseLevel.

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

◆ ReOptimize()

void G4RunManager::ReOptimize ( G4LogicalVolume * pLog )

inherited

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 G4RunManager::verboseLevel.

Referenced by G4RunManager::ReOptimizeMotherOf().

◆ ReOptimizeMotherOf()

void G4RunManager::ReOptimizeMotherOf ( G4VPhysicalVolume * pPhys )

inherited

Definition at line 1001 of file G4RunManager.cc.

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

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

◆ RestoreRandomNumberStatus()

void G4RunManager::RestoreRandomNumberStatus ( const G4String & fileN )

virtualinherited

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, G4RunManager::randomNumberStatusDir, and G4RunManager::verboseLevel.

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

◆ RestoreRndmEachEvent()

virtual void G4WorkerRunManager::RestoreRndmEachEvent ( G4bool flag )

inlinevirtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 89 of file G4WorkerRunManager.hh.

89{ readStatusFromFile=flag; }

References readStatusFromFile.

◆ rndmSaveThisEvent()

void G4WorkerRunManager::rndmSaveThisEvent ( )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 767 of file G4WorkerRunManager.cc.

{
  if(currentEvent == nullptr)
  {
    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;
  }
 
  std::ostringstream oos;
  oos << "G4Worker" << workerContext->GetThreadId() << "_"
      << "currentEvent.rndm"
      << "\0";
  G4String fileIn = randomNumberStatusDir + oos.str();
 
  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(), G4RunManager::currentEvent, G4RunManager::currentRun, G4cerr, G4cout, G4endl, G4Event::GetEventID(), G4Run::GetRunID(), G4WorkerThread::GetThreadId(), G4UImanager::GetUIpointer(), G4RunManager::randomNumberStatusDir, G4RunManager::storeRandomNumberStatus, G4RunManager::verboseLevel, and workerContext.

◆ rndmSaveThisRun()

void G4WorkerRunManager::rndmSaveThisRun ( )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 730 of file G4WorkerRunManager.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;
  }
 
  std::ostringstream oos;
  oos << "G4Worker" << workerContext->GetThreadId() << "_"
      << "currentRun.rndm"
      << "\0";
  G4String fileIn = randomNumberStatusDir + oos.str();
 
  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(), G4RunManager::currentRun, G4cerr, G4cout, G4endl, G4Run::GetRunID(), G4WorkerThread::GetThreadId(), G4UImanager::GetUIpointer(), G4RunManager::randomNumberStatusDir, G4RunManager::storeRandomNumberStatus, G4RunManager::verboseLevel, and workerContext.

◆ RunInitialization()

void G4WorkerRunManager::RunInitialization ( )

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 172 of file G4WorkerRunManager.cc.

{
#ifdef G4MULTITHREADED
  if(!visIsSetUp)
  {
    G4VVisManager* pVVis = G4VVisManager::GetConcreteInstance();
    if(pVVis != nullptr)
    {
      pVVis->SetUpForAThread();
      visIsSetUp = true;
    }
  }
#endif
 
  if(!(kernel->RunInitialization(fakeRun)))
    return;
 
  // Signal this thread can start event loop.
  // Note this will return only when all threads reach this point
  G4MTRunManager::GetMasterRunManager()->ThisWorkerReady();
  if(fakeRun)
    return;
 
  const G4UserWorkerInitialization* uwi =
    G4MTRunManager::GetMasterRunManager()->GetUserWorkerInitialization();
  CleanUpPreviousEvents();
  delete currentRun;
  currentRun = nullptr;
 
  if(fGeometryHasBeenDestroyed)
    G4ParallelWorldProcessStore::GetInstance()->UpdateWorlds();
  // Call a user hook: this is guaranteed all threads are "synchronized"
  if(uwi)
    uwi->WorkerRunStart();
 
  if(userRunAction)
    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())
  {
    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 on worker thread "
           << G4Threading::G4GetThreadId() << "."
           << G4endl;
  }
  if(userRunAction != nullptr)
    userRunAction->BeginOfRunAction(currentRun);
 
#if defined(GEANT4_USE_TIMEMORY)
  workerRunProfiler.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);
  }
 
  runAborted             = false;
  numberOfEventProcessed = 0;
}

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

◆ RunTermination()

void G4WorkerRunManager::RunTermination ( )

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 486 of file G4WorkerRunManager.cc.

{
  if(!fakeRun)
  {
#if defined(GEANT4_USE_TIMEMORY)
    workerRunProfiler.reset();
#endif
    MergePartialResults();
 
    // Call a user hook: note this is before the next barrier
    // so threads execute this method asyncrhonouzly
    //(TerminateRun allows for synch via G4RunAction::EndOfRun)
    const G4UserWorkerInitialization* uwi =
      G4MTRunManager::GetMasterRunManager()->GetUserWorkerInitialization();
    if(uwi != nullptr)
      uwi->WorkerRunEnd();
  }
 
  G4RunManager::RunTermination();
  // Signal this thread has finished envent-loop.
  // Note this will return only whan all threads reach this point
  G4MTRunManager::GetMasterRunManager()->ThisWorkerEndEventLoop();
}

References G4RunManager::fakeRun, G4MTRunManager::GetMasterRunManager(), G4RunManager::GetUserWorkerInitialization(), MergePartialResults(), G4RunManager::RunTermination(), G4MTRunManager::ThisWorkerEndEventLoop(), G4UserWorkerInitialization::WorkerRunEnd(), and workerRunProfiler.

◆ SetDCtable()

void G4RunManager::SetDCtable ( G4DCtable * DCtbl )

inlineinherited

Definition at line 573 of file G4RunManager.hh.

573{ DCtable = DCtbl; }

References G4RunManager::DCtable.

Referenced by G4DigiManager::AddNewModule().

◆ SetGeometryToBeOptimized()

void G4RunManager::SetGeometryToBeOptimized ( G4bool vl )

inlineinherited

Definition at line 317 of file G4RunManager.hh.

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

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

Referenced by G4RunMessenger::SetNewValue().

◆ SetNumberOfAdditionalWaitingStacks()

void G4RunManager::SetNumberOfAdditionalWaitingStacks ( G4int iAdd )

inlineinherited

Definition at line 422 of file G4RunManager.hh.

    {
      eventManager->SetNumberOfAdditionalWaitingStacks(iAdd);
    }

References G4RunManager::eventManager, and G4EventManager::SetNumberOfAdditionalWaitingStacks().

◆ SetNumberOfEventsToBeProcessed()

void G4RunManager::SetNumberOfEventsToBeProcessed ( G4int val )

inlineinherited

Definition at line 563 of file G4RunManager.hh.

    {
      numberOfEventToBeProcessed = val;
    }

References G4RunManager::numberOfEventToBeProcessed.

◆ SetNumberOfEventsToBeStored()

void G4RunManager::SetNumberOfEventsToBeStored ( G4int val )

inlineinherited

Definition at line 524 of file G4RunManager.hh.

    {
      n_perviousEventsToBeStored = val;
    }

References G4RunManager::n_perviousEventsToBeStored.

◆ SetNumberOfThreads()

virtual void G4RunManager::SetNumberOfThreads ( G4int )

inlinevirtualinherited

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 264 of file G4RunManager.hh.

264{}

◆ SetPrimaryTransformer()

void G4RunManager::SetPrimaryTransformer ( G4PrimaryTransformer * pt )

inlineinherited

Definition at line 436 of file G4RunManager.hh.

    {
      kernel->SetPrimaryTransformer(pt);
    }

References G4RunManager::kernel, and G4RunManagerKernel::SetPrimaryTransformer().

◆ SetPrintProgress()

void G4RunManager::SetPrintProgress ( G4int i )

inlineinherited

Definition at line 522 of file G4RunManager.hh.

522{ printModulo = i; }

References G4RunManager::printModulo.

Referenced by G4RunMessenger::SetNewValue().

◆ SetRandomNumberStore()

void G4RunManager::SetRandomNumberStore ( G4bool flag )

inlineinherited

Definition at line 456 of file G4RunManager.hh.

    {
      storeRandomNumberStatus = flag;
    }

References G4RunManager::storeRandomNumberStatus.

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

◆ SetRandomNumberStoreDir()

void G4RunManager::SetRandomNumberStoreDir ( const G4String & dir )

inlineinherited

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 G4RunManager::randomNumberStatusDir.

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

◆ SetRandomNumberStorePerEvent()

void G4RunManager::SetRandomNumberStorePerEvent ( G4bool flag )

inlineinherited

Definition at line 506 of file G4RunManager.hh.

    {
      rngStatusEventsFlag = flag;
    }

References G4RunManager::rngStatusEventsFlag.

Referenced by G4RunMessenger::SetNewValue().

◆ SetRunIDCounter()

void G4RunManager::SetRunIDCounter ( G4int i )

inlineinherited

Definition at line 558 of file G4RunManager.hh.

558{ runIDCounter = i; }

References G4RunManager::runIDCounter.

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

◆ SetupDefaultRNGEngine()

void G4WorkerRunManager::SetupDefaultRNGEngine ( )

private

Definition at line 679 of file G4WorkerRunManager.cc.

{
  const CLHEP::HepRandomEngine* mrnge =
    G4MTRunManager::GetMasterRunManager()->getMasterRandomEngine();
  const G4UserWorkerThreadInitialization* uwti =
    G4MTRunManager::GetMasterRunManager()->GetUserWorkerThreadInitialization();
  uwti->SetupRNGEngine(mrnge);
}

References G4MTRunManager::getMasterRandomEngine(), G4MTRunManager::GetMasterRunManager(), G4RunManager::GetUserWorkerThreadInitialization(), and G4UserWorkerThreadInitialization::SetupRNGEngine().

◆ SetUserAction() [1/6]

void G4WorkerRunManager::SetUserAction ( G4UserEventAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 691 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

References G4RunManager::SetUserAction().

◆ SetUserAction() [2/6]

void G4WorkerRunManager::SetUserAction ( G4UserRunAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 671 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(userAction);
  if(userAction != nullptr)
    userAction->SetMaster(false);
}

References G4UserRunAction::SetMaster(), and G4RunManager::SetUserAction().

Referenced by G4RTWorkerInitialization::WorkerRunEnd(), and G4RTWorkerInitialization::WorkerRunStart().

◆ SetUserAction() [3/6]

void G4WorkerRunManager::SetUserAction ( G4UserStackingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 703 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

References G4RunManager::SetUserAction().

◆ SetUserAction() [4/6]

void G4WorkerRunManager::SetUserAction ( G4UserSteppingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 715 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

References G4RunManager::SetUserAction().

◆ SetUserAction() [5/6]

void G4WorkerRunManager::SetUserAction ( G4UserTrackingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 709 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

References G4RunManager::SetUserAction().

◆ SetUserAction() [6/6]

void G4WorkerRunManager::SetUserAction ( G4VUserPrimaryGeneratorAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 697 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

References G4RunManager::SetUserAction().

◆ SetUserInitialization() [1/5]

void G4WorkerRunManager::SetUserInitialization ( G4UserWorkerInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 627 of file G4WorkerRunManager.cc.

{
  G4Exception(
    "G4RunManager::SetUserInitialization(G4UserWorkerInitialization*)",
    "Run0118", FatalException,
    "This method should be used only with an instance of G4MTRunManager");
}

References FatalException, and G4Exception().

◆ SetUserInitialization() [2/5]

void G4WorkerRunManager::SetUserInitialization ( G4UserWorkerThreadInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 636 of file G4WorkerRunManager.cc.

{
  G4Exception(
    "G4RunManager::SetUserInitialization(G4UserWorkerThreadInitialization*)",
    "Run0119", FatalException,
    "This method should be used only with an instance of G4MTRunManager");
}

References FatalException, and G4Exception().

◆ SetUserInitialization() [3/5]

void G4WorkerRunManager::SetUserInitialization ( G4VUserActionInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 646 of file G4WorkerRunManager.cc.

{
  G4Exception(
    "G4RunManager::SetUserInitialization(G4VUserActionInitialization*)",
    "Run0120", FatalException,
    "This method should be used only with an instance of G4MTRunManager");
}

References FatalException, and G4Exception().

◆ SetUserInitialization() [4/5]

void G4WorkerRunManager::SetUserInitialization ( G4VUserDetectorConstruction * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 655 of file G4WorkerRunManager.cc.

{
  G4Exception(
    "G4RunManager::SetUserInitialization(G4VUserDetectorConstruction*)",
    "Run0121", FatalException,
    "This method should be used only with an instance of G4MTRunManager");
}

References FatalException, and G4Exception().

◆ SetUserInitialization() [5/5]

void G4WorkerRunManager::SetUserInitialization ( G4VUserPhysicsList * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 664 of file G4WorkerRunManager.cc.

{
  pl->InitializeWorker();
  G4RunManager::SetUserInitialization(pl);
}

References G4VUserPhysicsList::InitializeWorker(), and G4RunManager::SetUserInitialization().

Referenced by G4MTRunManagerKernel::StartThread().

◆ SetVerboseLevel()

void G4RunManager::SetVerboseLevel ( G4int vl )

inlineinherited

Definition at line 515 of file G4RunManager.hh.

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

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

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

◆ SetWorkerThread()

void G4WorkerRunManager::SetWorkerThread ( G4WorkerThread * wc )

inline

Definition at line 74 of file G4WorkerRunManager.hh.

74{ workerContext = wc; }

References workerContext.

Referenced by G4MTRunManagerKernel::StartThread().

◆ StackPreviousEvent()

void G4RunManager::StackPreviousEvent ( G4Event * anEvent )

protectedinherited

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 G4RunManager::CleanUpUnnecessaryEvents(), G4RunManager::currentRun, G4Event::GetNumberOfGrips(), G4RunManager::n_perviousEventsToBeStored, G4RunManager::previousEvents, G4Run::StoreEvent(), and G4Event::ToBeKept().

Referenced by G4RunManager::TerminateOneEvent().

◆ StoreRandomNumberStatusToG4Event()

void G4RunManager::StoreRandomNumberStatusToG4Event ( G4int vl )

inlineinherited

Definition at line 441 of file G4RunManager.hh.

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

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

Referenced by G4RunMessenger::SetNewValue().

◆ StoreRNGStatus()

void G4WorkerRunManager::StoreRNGStatus ( const G4String & filenamePrefix )

protectedvirtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 721 of file G4WorkerRunManager.cc.

{
  std::ostringstream os;
  os << randomNumberStatusDir << "G4Worker" << workerContext->GetThreadId()
     << "_" << fn << ".rndm";
  G4Random::saveEngineStatus(os.str().c_str());
}

References G4WorkerThread::GetThreadId(), G4RunManager::randomNumberStatusDir, and workerContext.

Referenced by GenerateEvent(), and RunInitialization().

◆ TerminateEventLoop()

void G4WorkerRunManager::TerminateEventLoop ( )

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 511 of file G4WorkerRunManager.cc.

{
  if(verboseLevel > 0 && !fakeRun)
  {
    timer->Stop();
    G4cout << "Thread-local 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;
  }
}

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

Referenced by DoEventLoop().

◆ TerminateOneEvent()

void G4RunManager::TerminateOneEvent ( )

virtualinherited

Reimplemented in G4MTRunManager, and G4TaskRunManager.

Definition at line 469 of file G4RunManager.cc.

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

References G4RunManager::currentEvent, G4RunManager::numberOfEventProcessed, and G4RunManager::StackPreviousEvent().

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

◆ UpdateScoring()

void G4RunManager::UpdateScoring ( )

protectedinherited

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);
  }
}