#include <G4WorkerRunManager.hh>

Inheritance diagram for G4WorkerRunManager:

Public Types
using	ProfilerConfig = G4ProfilerConfig< G4ProfileType::Run >

Public Types inherited from G4RunManager
enum	RMType { sequentialRM , masterRM , workerRM }

using	ProfilerConfig = G4ProfilerConfig< G4ProfileType::Run >

Public Member Functions
	G4WorkerRunManager ()

	~G4WorkerRunManager ()

virtual void	InitializeGeometry ()

virtual void	RunInitialization ()

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

virtual void	ProcessOneEvent (G4int i_event)

virtual G4Event *	GenerateEvent (G4int i_event)

virtual void	RunTermination ()

virtual void	TerminateEventLoop ()

virtual void	DoWork ()

void	SetWorkerThread (G4WorkerThread *wc)
	Sets the worker context.

virtual void	SetUserInitialization (G4VUserPhysicsList *userInit)

virtual void	SetUserInitialization (G4VUserDetectorConstruction *userInit)

virtual void	SetUserInitialization (G4VUserActionInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit)

virtual void	SetUserAction (G4UserRunAction *userAction)

virtual void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction)

virtual void	SetUserAction (G4UserEventAction *userAction)

virtual void	SetUserAction (G4UserStackingAction *userAction)

virtual void	SetUserAction (G4UserTrackingAction *userAction)

virtual void	SetUserAction (G4UserSteppingAction *userAction)

virtual void	RestoreRndmEachEvent (G4bool flag)

Public Member Functions inherited from G4RunManager
	G4RunManager ()

virtual	~G4RunManager ()

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

virtual void	Initialize ()

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

virtual void	AbortRun (G4bool softAbort=false)

virtual void	AbortEvent ()

virtual void	InitializeGeometry ()

virtual void	InitializePhysics ()

virtual G4bool	ConfirmBeamOnCondition ()

virtual void	RunInitialization ()

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

virtual void	RunTermination ()

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

virtual void	ProcessOneEvent (G4int i_event)

virtual void	TerminateOneEvent ()

virtual void	TerminateEventLoop ()

virtual G4Event *	GenerateEvent (G4int i_event)

virtual void	AnalyzeEvent (G4Event *anEvent)

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

void	ConfigureProfilers (int argc, char **argv)

virtual void	SetNumberOfThreads (G4int)

virtual G4int	GetNumberOfThreads () const

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=0) const

virtual void	rndmSaveThisRun ()

virtual void	rndmSaveThisEvent ()

virtual void	RestoreRandomNumberStatus (const G4String &fileN)

virtual void	SetUserInitialization (G4VUserDetectorConstruction *userInit)

virtual void	SetUserInitialization (G4VUserPhysicsList *userInit)

virtual void	SetUserInitialization (G4VUserActionInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit)

virtual void	SetUserAction (G4UserRunAction *userAction)

virtual void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction)

virtual void	SetUserAction (G4UserEventAction *userAction)

virtual void	SetUserAction (G4UserStackingAction *userAction)

virtual void	SetUserAction (G4UserTrackingAction *userAction)

virtual void	SetUserAction (G4UserSteppingAction *userAction)

const G4VUserDetectorConstruction *	GetUserDetectorConstruction () const

const G4VUserPhysicsList *	GetUserPhysicsList () const

const G4VUserActionInitialization *	GetUserActionInitialization () const

G4VUserActionInitialization *	GetNonConstUserActionInitialization () const

const G4UserWorkerInitialization *	GetUserWorkerInitialization () const

const G4UserWorkerThreadInitialization *	GetUserWorkerThreadInitialization () const

const G4UserRunAction *	GetUserRunAction () const

const G4VUserPrimaryGeneratorAction *	GetUserPrimaryGeneratorAction () const

const G4UserEventAction *	GetUserEventAction () const

const G4UserStackingAction *	GetUserStackingAction () const

const G4UserTrackingAction *	GetUserTrackingAction () const

const G4UserSteppingAction *	GetUserSteppingAction () const

void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)

const G4String &	GetVersionString () const

void	SetPrimaryTransformer (G4PrimaryTransformer *pt)

void	StoreRandomNumberStatusToG4Event (G4int vl)

G4int	GetFlagRandomNumberStatusToG4Event () const

void	SetRandomNumberStore (G4bool flag)

G4bool	GetRandomNumberStore () const

void	SetRandomNumberStoreDir (const G4String &dir)

const G4String &	GetRandomNumberStoreDir () const

const G4String &	GetRandomNumberStatusForThisRun () const

const G4String &	GetRandomNumberStatusForThisEvent () const

void	SetRandomNumberStorePerEvent (G4bool flag)

G4bool	GetRandomNumberStorePerEvent () const

void	GeometryHasBeenModified (G4bool prop=true)

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

void	PhysicsHasBeenModified ()

void	CutOffHasBeenModified ()

void	ReOptimizeMotherOf (G4VPhysicalVolume *)

void	ReOptimize (G4LogicalVolume *)

void	SetVerboseLevel (G4int vl)

G4int	GetVerboseLevel () const

G4int	GetPrintProgress ()

void	SetPrintProgress (G4int i)

void	SetGeometryToBeOptimized (G4bool vl)

G4bool	GetGeometryToBeOptimized ()

void	SetNumberOfEventsToBeStored (G4int val)

const G4Run *	GetCurrentRun () const

G4Run *	GetNonConstCurrentRun () const

const G4Event *	GetCurrentEvent () const

const G4Event *	GetPreviousEvent (G4int i) const

void	SetRunIDCounter (G4int i)

G4int	GetNumberOfParallelWorld () const

void	SetNumberOfEventsToBeProcessed (G4int val)

G4int	GetNumberOfEventsToBeProcessed () const

G4int	GetNumberOfSelectEvents () const

G4String	GetSelectMacro () const

void	SetDCtable (G4DCtable *DCtbl)

RMType	GetRunManagerType () const

virtual void	ConstructScoringWorlds ()

virtual void	RestoreRndmEachEvent (G4bool)

void	GeometryDirectlyUpdated (G4bool val=true)

Static Public Member Functions
static G4WorkerRunManager *	GetWorkerRunManager ()

static G4WorkerRunManagerKernel *	GetWorkerRunManagerKernel ()

Static Public Member Functions inherited from G4RunManager
static G4RunManager *	GetRunManager ()

static G4bool	IfGeometryHasBeenDestroyed ()

Protected Member Functions
virtual void	ConstructScoringWorlds ()

virtual void	StoreRNGStatus (const G4String &filenamePrefix)

virtual void	rndmSaveThisRun ()

virtual void	rndmSaveThisEvent ()

virtual void	MergePartialResults ()

Protected Member Functions inherited from G4RunManager
void	CleanUpPreviousEvents ()

void	CleanUpUnnecessaryEvents (G4int keepNEvents)

void	StackPreviousEvent (G4Event *anEvent)

	G4RunManager (RMType rmType)

virtual void	StoreRNGStatus (const G4String &filenamePrefix)

void	UpdateScoring ()

virtual void	DeleteUserInitializations ()

Protected Attributes
G4WorkerThread *	workerContext

G4bool	eventLoopOnGoing

G4bool	runIsSeeded

G4int	nevModulo

G4int	currEvID

G4int	luxury

G4SeedsQueue	seedsQueue

G4bool	readStatusFromFile

Protected Attributes inherited from G4RunManager
G4RunManagerKernel *	kernel

G4EventManager *	eventManager

G4VUserDetectorConstruction *	userDetector

G4VUserPhysicsList *	physicsList

G4VUserActionInitialization *	userActionInitialization

G4UserWorkerInitialization *	userWorkerInitialization

G4UserWorkerThreadInitialization *	userWorkerThreadInitialization

G4UserRunAction *	userRunAction

G4VUserPrimaryGeneratorAction *	userPrimaryGeneratorAction

G4UserEventAction *	userEventAction

G4UserStackingAction *	userStackingAction

G4UserTrackingAction *	userTrackingAction

G4UserSteppingAction *	userSteppingAction

G4bool	geometryInitialized

G4bool	physicsInitialized

G4bool	runAborted

G4bool	initializedAtLeastOnce

G4bool	geometryToBeOptimized

G4int	runIDCounter

G4int	verboseLevel

G4int	printModulo

G4Timer *	timer

G4DCtable *	DCtable

G4Run *	currentRun

G4Event *	currentEvent

std::list< G4Event * > *	previousEvents

G4int	n_perviousEventsToBeStored

G4int	numberOfEventToBeProcessed

G4bool	storeRandomNumberStatus

G4int	storeRandomNumberStatusToG4Event

G4String	randomNumberStatusDir

G4String	randomNumberStatusForThisRun

G4String	randomNumberStatusForThisEvent

G4bool	rngStatusEventsFlag

G4VPhysicalVolume *	currentWorld

G4int	nParallelWorlds

G4String	msgText

G4int	n_select_msg

G4int	numberOfEventProcessed

G4String	selectMacro

G4bool	fakeRun

G4bool	isScoreNtupleWriter

RMType	runManagerType

G4bool	geometryDirectlyUpdated

Additional Inherited Members
Static Protected Attributes inherited from G4RunManager
static G4RUN_DLL G4bool	fGeometryHasBeenDestroyed = false

Detailed Description

Definition at line 47 of file G4WorkerRunManager.hh.

Member Typedef Documentation

◆ ProfilerConfig

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

Definition at line 50 of file G4WorkerRunManager.hh.

Constructor & Destructor Documentation

◆ G4WorkerRunManager()

G4WorkerRunManager::G4WorkerRunManager ( )

Definition at line 64 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)
    G4ScoringManager::GetScoringManager();  // TLS instance for a worker
 
  eventLoopOnGoing   = false;
  runIsSeeded        = false;
  nevModulo          = -1;
  currEvID           = -1;
  workerContext      = 0;
  readStatusFromFile = false;
 
  // 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();
  }
  else
  {
    luxury = -1;
  }
 
  G4UImanager::GetUIpointer()->SetIgnoreCmdNotFound(true);
 
#ifdef G4MULTITHREADED
  G4VVisManager* pVVis = G4VVisManager::GetConcreteInstance();
  if(pVVis)
  {
    pVVis->SetUpForAThread();
    visIsSetUp = true;
  }
  else
  {
    visIsSetUp = false;
  }
#endif
}

◆ ~G4WorkerRunManager()

G4WorkerRunManager::~G4WorkerRunManager ( )

Definition at line 128 of file G4WorkerRunManager.cc.

{
  // Delete thread-local data process manager objects
  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                   = 0;
  userWorkerInitialization       = 0;
  userWorkerThreadInitialization = 0;
  userActionInitialization       = 0;
  physicsList                    = 0;
  if(verboseLevel > 0)
    G4cout << "Destroying WorkerRunManager (" << this << ")" << G4endl;
}

Member Function Documentation

◆ ConstructScoringWorlds()

void G4WorkerRunManager::ConstructScoringWorlds ( )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 551 of file G4WorkerRunManager.cc.

{
  using MeshShape = G4VScoringMesh::MeshShape;
 
  // Return if unnecessary
  G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
  if(!ScM)
    return;
  G4int nPar = ScM->GetNumberOfMesh();
  if(nPar < 1)
    return;
 
  // Update thread-local G4TransportationManager of all the world volumes
  kernel->WorkerUpdateWorldVolume();
 
  G4ScoringManager* masterScM = G4MTRunManager::GetMasterScoringManager();
  assert(masterScM != NULL);
 
  G4ParticleTable::G4PTblDicIterator* 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)
      {
        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)
        {
          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)
            {
              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);
  }
}

Referenced by G4WorkerTaskRunManager::DoWork().

◆ 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 277 of file G4WorkerRunManager.cc.

{
  if(!userPrimaryGeneratorAction)
  {
    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 = workerContext->GetThreadId();
  G4int i_event = -1;
  nevModulo     = -1;
  currEvID      = -1;
 
  while(eventLoopOnGoing)
  {
    ProcessOneEvent(i_event);
    if(eventLoopOnGoing)
    {
      TerminateOneEvent();
      if(runAborted)
      {
        eventLoopOnGoing = false;
      }
      //////        else
      //////        {
      //////          i_event += workerContext->GetNumberThreads();
      //////          eventLoopOnGoing = i_event<n_event;
      //////        }
    }
  }
 
  TerminateEventLoop();
}

◆ DoWork()

void G4WorkerRunManager::DoWork ( )

virtual

Reimplemented in G4WorkerTaskRunManager.

Definition at line 804 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
      std::vector<G4String>::const_iterator it = cmds.begin();
      for(; it != cmds.end(); 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
      std::vector<G4String>::const_iterator it = cmds.begin();
      for(; it != cmds.end(); 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;
}

Referenced by G4MTRunManagerKernel::StartThread().

◆ GenerateEvent()

G4Event * G4WorkerRunManager::GenerateEvent ( G4int i_event )

virtual

virtual void BuildPhysicsTables();

G4cout<<"Event "<<currEvID<<" is seeded with { "<<s1<<", "<<s2<<" }"<<G4endl;

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 340 of file G4WorkerRunManager.cc.

{
  G4Event* anEvent          = new G4Event(i_event);
  long s1                   = 0;
  long s2                   = 0;
  long 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 0;
    }
  }
  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)
  {
    long seeds[3] = { s1, s2, 0 };
    G4Random::setTheSeeds(seeds, luxury);
    runIsSeeded = true;
    ////G4cout<<"Event "<<currEvID<<" is seeded with { "<<s1<<", "<<s2<<"
    ///}"<<G4endl;
  }
 
  // 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;
}

Referenced by ProcessOneEvent().

◆ GetWorkerRunManager()

G4WorkerRunManager * G4WorkerRunManager::GetWorkerRunManager ( )

static

Definition at line 54 of file G4WorkerRunManager.cc.

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

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

◆ GetWorkerRunManagerKernel()

G4WorkerRunManagerKernel * G4WorkerRunManager::GetWorkerRunManagerKernel ( )

static

Definition at line 59 of file G4WorkerRunManager.cc.

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

◆ InitializeGeometry()

void G4WorkerRunManager::InitializeGeometry ( )

virtual

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

Reimplemented from G4RunManager.

Definition at line 146 of file G4WorkerRunManager.cc.

{
  if(!userDetector)
  {
    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;
}

◆ MergePartialResults()

void G4WorkerRunManager::MergePartialResults ( )

protectedvirtual

Definition at line 476 of file G4WorkerRunManager.cc.

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

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

◆ ProcessOneEvent()

void G4WorkerRunManager::ProcessOneEvent ( G4int i_event )

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

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

Referenced by DoEventLoop().

◆ RestoreRndmEachEvent()

virtual void G4WorkerRunManager::RestoreRndmEachEvent ( G4bool flag )

inlinevirtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 127 of file G4WorkerRunManager.hh.

127{ readStatusFromFile = flag; }

◆ rndmSaveThisEvent()

void G4WorkerRunManager::rndmSaveThisEvent ( )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 763 of file G4WorkerRunManager.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;
  }
 
  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; }
}

◆ rndmSaveThisRun()

void G4WorkerRunManager::rndmSaveThisRun ( )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 731 of file G4WorkerRunManager.cc.

{
  G4int runNumber = 0;
  if(currentRun) 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; }
}

◆ RunInitialization()

void G4WorkerRunManager::RunInitialization ( )

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 175 of file G4WorkerRunManager.cc.

{
#ifdef G4MULTITHREADED
  if(!visIsSetUp)
  {
    G4VVisManager* pVVis = G4VVisManager::GetConcreteInstance();
    if(pVVis)
    {
      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();
  if(currentRun)
    delete currentRun;
  currentRun = 0;
 
  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)
    currentRun = new G4Run();
 
  currentRun->SetRunID(runIDCounter);
  currentRun->SetNumberOfEventToBeProcessed(numberOfEventToBeProcessed);
 
  currentRun->SetDCtable(DCtable);
  G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
  if(fSDM)
  {
    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((G4Event*) 0);
  }
 
  if(printModulo > 0 || verboseLevel > 0)
  {
    G4cout << "### Run " << currentRun->GetRunID()
           << " starts on worker thread " << G4Threading::G4GetThreadId() << "."
           << G4endl;
  }
  if(userRunAction)
    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;
}

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

◆ SetUserAction() [1/6]

void G4WorkerRunManager::SetUserAction ( G4UserEventAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 698 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

◆ SetUserAction() [2/6]

void G4WorkerRunManager::SetUserAction ( G4UserRunAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 680 of file G4WorkerRunManager.cc.

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

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

◆ SetUserAction() [3/6]

void G4WorkerRunManager::SetUserAction ( G4UserStackingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 708 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

◆ SetUserAction() [4/6]

void G4WorkerRunManager::SetUserAction ( G4UserSteppingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 718 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

◆ SetUserAction() [5/6]

void G4WorkerRunManager::SetUserAction ( G4UserTrackingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 713 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

◆ SetUserAction() [6/6]

void G4WorkerRunManager::SetUserAction ( G4VUserPrimaryGeneratorAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 703 of file G4WorkerRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

◆ SetUserInitialization() [1/5]

void G4WorkerRunManager::SetUserInitialization ( G4UserWorkerInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 641 of file G4WorkerRunManager.cc.

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

◆ SetUserInitialization() [2/5]

void G4WorkerRunManager::SetUserInitialization ( G4UserWorkerThreadInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 649 of file G4WorkerRunManager.cc.

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

◆ SetUserInitialization() [3/5]

void G4WorkerRunManager::SetUserInitialization ( G4VUserActionInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 658 of file G4WorkerRunManager.cc.

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

◆ SetUserInitialization() [4/5]

void G4WorkerRunManager::SetUserInitialization ( G4VUserDetectorConstruction * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 666 of file G4WorkerRunManager.cc.

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

◆ SetUserInitialization() [5/5]

void G4WorkerRunManager::SetUserInitialization ( G4VUserPhysicsList * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 674 of file G4WorkerRunManager.cc.

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

Referenced by G4MTRunManagerKernel::StartThread().

◆ SetWorkerThread()

void G4WorkerRunManager::SetWorkerThread ( G4WorkerThread * wc )

inline

Sets the worker context.

Definition at line 89 of file G4WorkerRunManager.hh.

89{ workerContext = wc; }

Referenced by G4MTRunManagerKernel::StartThread().

◆ StoreRNGStatus()

void G4WorkerRunManager::StoreRNGStatus ( const G4String & filenamePrefix )

protectedvirtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

Definition at line 723 of file G4WorkerRunManager.cc.

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

Referenced by GenerateEvent(), and RunInitialization().

◆ TerminateEventLoop()

void G4WorkerRunManager::TerminateEventLoop ( )

virtual

Reimplemented from G4RunManager.

Reimplemented in G4WorkerTaskRunManager.

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

Referenced by DoEventLoop().

Member Data Documentation

◆ currEvID

G4int G4WorkerRunManager::currEvID

protected

Definition at line 118 of file G4WorkerRunManager.hh.

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

◆ eventLoopOnGoing

G4bool G4WorkerRunManager::eventLoopOnGoing

protected

Definition at line 115 of file G4WorkerRunManager.hh.

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

◆ luxury

G4int G4WorkerRunManager::luxury

protected

Definition at line 119 of file G4WorkerRunManager.hh.

Referenced by G4WorkerRunManager(), and GenerateEvent().

◆ nevModulo

G4int G4WorkerRunManager::nevModulo

protected

Definition at line 117 of file G4WorkerRunManager.hh.

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

◆ readStatusFromFile

G4bool G4WorkerRunManager::readStatusFromFile

protected

Definition at line 121 of file G4WorkerRunManager.hh.

Referenced by G4WorkerRunManager(), GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), RestoreRndmEachEvent(), and G4WorkerTaskRunManager::RestoreRndmEachEvent().

◆ runIsSeeded

G4bool G4WorkerRunManager::runIsSeeded

protected

Definition at line 116 of file G4WorkerRunManager.hh.

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

◆ seedsQueue

G4SeedsQueue G4WorkerRunManager::seedsQueue

protected

Definition at line 120 of file G4WorkerRunManager.hh.

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

◆ workerContext

G4WorkerThread* G4WorkerRunManager::workerContext

protected

Definition at line 92 of file G4WorkerRunManager.hh.

Referenced by DoWork(), G4WorkerTaskRunManager::DoWork(), G4WorkerRunManager(), G4WorkerTaskRunManager::GetWorkerThread(), rndmSaveThisEvent(), rndmSaveThisRun(), SetWorkerThread(), StoreRNGStatus(), G4WorkerTaskRunManager::StoreRNGStatus(), and G4WorkerTaskRunManager::TerminateEventLoop().

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ProfilerConfig

Constructor & Destructor Documentation

◆ G4WorkerRunManager()

◆ ~G4WorkerRunManager()

Member Function Documentation

◆ ConstructScoringWorlds()

◆ DoEventLoop()

◆ DoWork()

◆ GenerateEvent()

◆ GetWorkerRunManager()

◆ GetWorkerRunManagerKernel()

◆ InitializeGeometry()

◆ MergePartialResults()

◆ ProcessOneEvent()

◆ RestoreRndmEachEvent()

◆ rndmSaveThisEvent()

◆ rndmSaveThisRun()

◆ RunInitialization()

◆ RunTermination()

◆ SetUserAction() [1/6]

◆ SetUserAction() [2/6]

◆ SetUserAction() [3/6]

◆ SetUserAction() [4/6]

◆ SetUserAction() [5/6]

◆ SetUserAction() [6/6]

◆ SetUserInitialization() [1/5]

◆ SetUserInitialization() [2/5]

◆ SetUserInitialization() [3/5]

◆ SetUserInitialization() [4/5]

◆ SetUserInitialization() [5/5]

◆ SetWorkerThread()

◆ StoreRNGStatus()

◆ TerminateEventLoop()

Member Data Documentation

◆ currEvID

◆ eventLoopOnGoing

◆ luxury

◆ nevModulo

◆ readStatusFromFile

◆ runIsSeeded

◆ seedsQueue

◆ workerContext