#include <G4WorkerTaskRunManager.hh>

Inheritance diagram for G4WorkerTaskRunManager:

Public Types
using	G4StrVector = std::vector<G4String>

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

Public Member Functions
	G4WorkerTaskRunManager ()=default

void	RunInitialization () override

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

void	ProcessOneEvent (G4int i_event) override

G4Event *	GenerateEvent (G4int i_event) override

void	RunTermination () override

void	TerminateEventLoop () override

void	DoWork () override

void	RestoreRndmEachEvent (G4bool flag) override

virtual void	DoCleanup ()

virtual void	ProcessUI ()

G4WorkerThread *	GetWorkerThread () const

G4StrVector	GetCommandStack () const

Public Member Functions inherited from G4WorkerRunManager
	G4WorkerRunManager ()

	~G4WorkerRunManager () override

void	InitializeGeometry () override

void	SetWorkerThread (G4WorkerThread *wc)

void	SetUserInitialization (G4VUserPhysicsList *userInit) override

void	SetUserInitialization (G4VUserDetectorConstruction *userInit) override

void	SetUserInitialization (G4VUserActionInitialization *userInit) override

void	SetUserInitialization (G4UserWorkerInitialization *userInit) override

void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit) override

void	SetUserAction (G4UserRunAction *userAction) override

void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction) override

void	SetUserAction (G4UserEventAction *userAction) override

void	SetUserAction (G4UserStackingAction *userAction) override

void	SetUserAction (G4UserTrackingAction *userAction) override

void	SetUserAction (G4UserSteppingAction *userAction) override

Public Member Functions inherited from G4RunManager
	G4RunManager ()

virtual	~G4RunManager ()

	G4RunManager (const G4RunManager &)=delete

G4RunManager &	operator= (const G4RunManager &)=delete

virtual void	BeamOn (G4int n_event, const char *macroFile=nullptr, 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	InitializePhysics ()

virtual G4bool	ConfirmBeamOnCondition ()

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

virtual void	TerminateOneEvent ()

virtual void	AnalyzeEvent (G4Event *anEvent)

virtual void	SetNumberOfThreads (G4int)

virtual G4int	GetNumberOfThreads () const

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=nullptr) 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	SetGeometryToBeOptimized (G4bool vl)

G4bool	GetGeometryToBeOptimized ()

void	GeometryDirectlyUpdated (G4bool val=true)

virtual void	RestoreRandomNumberStatus (const G4String &fileN)

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)

void	SetDefaultClassification (G4TrackStatus ts, G4ClassificationOfNewTrack val, G4ExceptionSeverity es=G4ExceptionSeverity::IgnoreTheIssue)

void	SetDefaultClassification (const G4ParticleDefinition *pd, G4ClassificationOfNewTrack val, G4ExceptionSeverity es=G4ExceptionSeverity::IgnoreTheIssue)

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	SetVerboseLevel (G4int vl)

G4int	GetVerboseLevel () const

G4int	GetPrintProgress ()

void	SetPrintProgress (G4int i)

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

const G4String &	GetSelectMacro () const

void	SetDCtable (G4DCtable *DCtbl)

RMType	GetRunManagerType () const

virtual void	RegisterSubEventType (G4int, G4int)

virtual void	MergeTrajectories (const G4SubEvent , const G4Event )

virtual void	UpdateScoringForSubEvent (const G4SubEvent , const G4Event )

virtual const G4SubEvent *	GetSubEvent (G4int, G4bool &, G4long &, G4long &, G4long &, G4bool)

virtual void	SubEventFinished (const G4SubEvent , const G4Event )

virtual G4int	GetSubEventType () const

virtual void	SetSubEventType (G4int)

virtual std::size_t	GetMaxNTrack () const

virtual void	TrajectoriesToBeMerged (G4bool)

virtual void	ReportEventDeletion (const G4Event *evt)

void	ResetNavigatorAtInitialization (G4bool val=true)

Static Public Member Functions
static G4WorkerTaskRunManager *	GetWorkerRunManager ()

static G4WorkerTaskRunManagerKernel *	GetWorkerRunManagerKernel ()

Static Public Member Functions inherited from G4WorkerRunManager
static G4WorkerRunManager *	GetWorkerRunManager ()

static G4WorkerRunManagerKernel *	GetWorkerRunManagerKernel ()

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

static G4bool	IfGeometryHasBeenDestroyed ()

Protected Member Functions
void	StoreRNGStatus (const G4String &filenamePrefix) override

void	SetupDefaultRNGEngine () override

Protected Member Functions inherited from G4WorkerRunManager
void	ConstructScoringWorlds () override

void	rndmSaveThisRun () override

void	rndmSaveThisEvent () override

virtual void	MergePartialResults (G4bool mergeEvents=true)

Protected Member Functions inherited from G4RunManager
	G4RunManager (RMType rmType)

virtual void	StackPreviousEvent (G4Event *anEvent)

virtual void	CleanUpPreviousEvents ()

virtual void	CleanUpUnnecessaryEvents (G4int keepNEvents)

void	UpdateScoring (const G4Event *evt=nullptr)

virtual void	DeleteUserInitializations ()

Protected Attributes
G4StrVector	processedCommandStack

Protected Attributes inherited from G4WorkerRunManager
G4WorkerThread *	workerContext = nullptr

G4bool	eventLoopOnGoing = false

G4bool	runIsSeeded = false

G4int	nevModulo = -1

G4int	currEvID = -1

G4int	luxury = -1

G4SeedsQueue	seedsQueue

G4bool	readStatusFromFile = false

Protected Attributes inherited from G4RunManager
G4RunManagerKernel *	kernel = nullptr

G4EventManager *	eventManager = nullptr

G4VUserDetectorConstruction *	userDetector = nullptr

G4VUserPhysicsList *	physicsList = nullptr

G4VUserActionInitialization *	userActionInitialization = nullptr

G4UserWorkerInitialization *	userWorkerInitialization = nullptr

G4UserWorkerThreadInitialization *	userWorkerThreadInitialization = nullptr

G4UserRunAction *	userRunAction = nullptr

G4VUserPrimaryGeneratorAction *	userPrimaryGeneratorAction = nullptr

G4UserEventAction *	userEventAction = nullptr

G4UserStackingAction *	userStackingAction = nullptr

G4UserTrackingAction *	userTrackingAction = nullptr

G4UserSteppingAction *	userSteppingAction = nullptr

G4bool	geometryInitialized = false

G4bool	physicsInitialized = false

G4bool	runAborted = false

G4bool	initializedAtLeastOnce = false

G4bool	geometryToBeOptimized = true

G4int	runIDCounter = 0

G4int	verboseLevel = 0

G4int	printModulo = -1

G4Timer *	timer = nullptr

G4DCtable *	DCtable = nullptr

G4Run *	currentRun = nullptr

G4Event *	currentEvent = nullptr

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

G4int	n_perviousEventsToBeStored = 0

G4int	numberOfEventToBeProcessed = 0

G4bool	storeRandomNumberStatus = false

G4int	storeRandomNumberStatusToG4Event = 0

G4String	randomNumberStatusDir = "./"

G4String	randomNumberStatusForThisRun = ""

G4String	randomNumberStatusForThisEvent = ""

G4bool	rngStatusEventsFlag = false

G4VPhysicalVolume *	currentWorld = nullptr

G4int	nParallelWorlds = 0

G4String	msgText = " "

G4int	n_select_msg = -1

G4int	numberOfEventProcessed = 0

G4String	selectMacro = ""

G4bool	fakeRun = false

G4bool	isScoreNtupleWriter = false

G4bool	geometryDirectlyUpdated = false

RMType	runManagerType

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

Detailed Description

Definition at line 48 of file G4WorkerTaskRunManager.hh.

Member Typedef Documentation

◆ G4StrVector

using G4WorkerTaskRunManager::G4StrVector = std::vector<G4String>

Definition at line 51 of file G4WorkerTaskRunManager.hh.

Constructor & Destructor Documentation

◆ G4WorkerTaskRunManager()

G4WorkerTaskRunManager::G4WorkerTaskRunManager ( )

default

Referenced by GetWorkerRunManager().

Member Function Documentation

◆ DoCleanup()

void G4WorkerTaskRunManager::DoCleanup ( )

virtual

Reimplemented in G4WorkerSubEvtRunManager.

Definition at line 418 of file G4WorkerTaskRunManager.cc.

{
  CleanUpPreviousEvents();
 
  delete currentRun;
  currentRun = nullptr;
}

◆ DoEventLoop()

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

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 163 of file G4WorkerTaskRunManager.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.empty())
    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;
 
  for (G4int evt = 0; evt < n_event; ++evt) {
    ProcessOneEvent(i_event);
    if (eventLoopOnGoing) {
      TerminateOneEvent();
      if (runAborted) eventLoopOnGoing = false;
    }
    if (!eventLoopOnGoing) break;
  }
}

Referenced by DoWork().

◆ DoWork()

void G4WorkerTaskRunManager::DoWork ( )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 428 of file G4WorkerTaskRunManager.cc.

{
  G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
  G4bool newRun = false;
  const G4Run* run = mrm->GetCurrentRun();
  G4ThreadLocalStatic G4int runId = -1;
  if ((run != nullptr) && run->GetRunID() != runId) {
    runId = run->GetRunID();
    newRun = true;
    if (runId > 0) {
      ProcessUI();
      assert(workerContext != nullptr);
    }
    workerContext->UpdateGeometryAndPhysicsVectorFromMaster();
  }
 
  // Start this run
  G4int nevts = mrm->GetNumberOfEventsPerTask();
  G4int numSelect = mrm->GetNumberOfSelectEvents();
  G4String macroFile = mrm->GetSelectMacro();
  G4bool empty_macro = (macroFile.empty() || macroFile == " ");
 
  const char* macro = (empty_macro) ? nullptr : macroFile.c_str();
  numSelect = (empty_macro) ? -1 : numSelect;
 
  if (newRun) {
    G4bool cond = ConfirmBeamOnCondition();
    if (cond) {
      ConstructScoringWorlds();
      RunInitialization();
    }
  }
  DoEventLoop(nevts, macro, numSelect);
}

Referenced by G4SubEvtRunManager::CreateAndStartWorkers(), and G4TaskRunManager::CreateAndStartWorkers().

◆ GenerateEvent()

G4Event * G4WorkerTaskRunManager::GenerateEvent ( G4int i_event )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 216 of file G4WorkerTaskRunManager.cc.

{
  auto 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) {
      anEvent->ScoresRecorded();
      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, -1);
    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;
}

Referenced by ProcessOneEvent().

◆ GetCommandStack()

G4StrVector G4WorkerTaskRunManager::GetCommandStack ( ) const

inline

Definition at line 71 of file G4WorkerTaskRunManager.hh.

71{ return processedCommandStack; }

G4WorkerTaskRunManager::processedCommandStack

G4StrVector processedCommandStack

Definition G4WorkerTaskRunManager.hh:80

◆ GetWorkerRunManager()

G4WorkerTaskRunManager * G4WorkerTaskRunManager::GetWorkerRunManager ( )

static

Definition at line 60 of file G4WorkerTaskRunManager.cc.

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

Referenced by G4SubEvtRunManager::CreateAndStartWorkers(), G4TaskRunManager::CreateAndStartWorkers(), and GetWorkerRunManagerKernel().

◆ GetWorkerRunManagerKernel()

G4WorkerTaskRunManagerKernel * G4WorkerTaskRunManager::GetWorkerRunManagerKernel ( )

static

Definition at line 67 of file G4WorkerTaskRunManager.cc.

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

◆ GetWorkerThread()

G4WorkerThread * G4WorkerTaskRunManager::GetWorkerThread ( ) const

inline

Definition at line 70 of file G4WorkerTaskRunManager.hh.

70{ return workerContext; }

◆ ProcessOneEvent()

void G4WorkerTaskRunManager::ProcessOneEvent ( G4int i_event )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 199 of file G4WorkerTaskRunManager.cc.

{
  currentEvent = GenerateEvent(i_event);
  if (eventLoopOnGoing) {
    eventManager->ProcessOneEvent(currentEvent);
    AnalyzeEvent(currentEvent);
    UpdateScoring();
    if (currentEvent->GetEventID() < n_select_msg) {
      G4cout << "Applying command \"" << msgText << "\" @ " << __FUNCTION__ << ":" << __LINE__
             << G4endl;
      G4UImanager::GetUIpointer()->ApplyCommand(msgText);
    }
  }
}

Referenced by DoEventLoop().

◆ ProcessUI()

void G4WorkerTaskRunManager::ProcessUI ( )

virtual

Reimplemented in G4WorkerSubEvtRunManager.

Definition at line 390 of file G4WorkerTaskRunManager.cc.

{
  G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
  if (mrm == nullptr) return;
 
  //------------------------------------------------------------------------//
  // Check UI commands not already processed
  auto command_stack = mrm->GetCommandStack();
  bool matching = (command_stack.size() == processedCommandStack.size());
  if (matching) {
    for (uintmax_t i = 0; i < command_stack.size(); ++i)
      if (processedCommandStack.at(i) != command_stack.at(i)) {
        matching = false;
        break;
      }
  }
 
  //------------------------------------------------------------------------//
  // Execute UI commands stored in the master UI manager
  if (!matching) {
    for (const auto& itr : command_stack)
      G4UImanager::GetUIpointer()->ApplyCommand(itr);
    processedCommandStack = std::move(command_stack);
  }
}

Referenced by DoWork().

◆ RestoreRndmEachEvent()

void G4WorkerTaskRunManager::RestoreRndmEachEvent ( G4bool flag )

inlineoverridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 66 of file G4WorkerTaskRunManager.hh.

66{ readStatusFromFile = flag; }

◆ RunInitialization()

void G4WorkerTaskRunManager::RunInitialization ( )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 74 of file G4WorkerTaskRunManager.cc.

{
#ifdef G4MULTITHREADED
  if (!visIsSetUp) {
    G4VVisManager* pVVis = G4VVisManager::GetConcreteInstance();
    if (pVVis != nullptr) {
      pVVis->SetUpForAThread();
      visIsSetUp = true;
    }
  }
#endif
  runIsSeeded = false;
 
  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 (IfGeometryHasBeenDestroyed()) G4ParallelWorldProcessStore::GetInstance()->UpdateWorlds();
 
  // Call a user hook: this is guaranteed all threads are "synchronized"
  if (uwi != nullptr) uwi->WorkerRunStart();
 
  if (userRunAction != nullptr) currentRun = userRunAction->GenerateRun();
  if (currentRun == nullptr) currentRun = new G4Run();
 
  currentRun->SetRunID(runIDCounter);
  G4TaskRunManager* mrm = G4TaskRunManager::GetMasterRunManager();
  numberOfEventToBeProcessed = mrm->GetNumberOfEventsToBeProcessed();
  currentRun->SetNumberOfEventToBeProcessed(numberOfEventToBeProcessed);
 
  currentRun->SetDCtable(DCtable);
  G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
  if (fSDM != nullptr) {
    currentRun->SetHCtable(fSDM->GetHCtable());
  }
 
  if (G4VScoreNtupleWriter::Instance() != nullptr) {
    auto hce = (fSDM != nullptr) ? fSDM->PrepareNewEvent() : nullptr;
    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 (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;
}

Referenced by DoWork().

◆ RunTermination()

void G4WorkerTaskRunManager::RunTermination ( )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 327 of file G4WorkerTaskRunManager.cc.

{
  if (!fakeRun && (currentRun != nullptr)) {
    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();
  }
 
  if (currentRun != nullptr) {
    G4RunManager::RunTermination();
  }
  // Signal this thread has finished envent-loop.
  // Note this will return only whan all threads reach this point
  G4MTRunManager::GetMasterRunManager()->ThisWorkerEndEventLoop();
}

Referenced by G4TaskRunManagerKernel::TerminateWorkerRunEventLoop().

◆ SetupDefaultRNGEngine()

void G4WorkerTaskRunManager::SetupDefaultRNGEngine ( )

overrideprotectedvirtual

Reimplemented from G4WorkerRunManager.

Definition at line 369 of file G4WorkerTaskRunManager.cc.

{
  const CLHEP::HepRandomEngine* mrnge =
    G4MTRunManager::GetMasterRunManager()->getMasterRandomEngine();
  assert(mrnge);  // Master has created RNG
  const G4UserWorkerThreadInitialization* uwti =
    G4MTRunManager::GetMasterRunManager()->GetUserWorkerThreadInitialization();
  uwti->SetupRNGEngine(mrnge);
}

◆ StoreRNGStatus()

void G4WorkerTaskRunManager::StoreRNGStatus ( const G4String & filenamePrefix )

overrideprotectedvirtual

Reimplemented from G4WorkerRunManager.

Definition at line 381 of file G4WorkerTaskRunManager.cc.

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

Referenced by GenerateEvent(), and RunInitialization().

◆ TerminateEventLoop()

void G4WorkerTaskRunManager::TerminateEventLoop ( )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 350 of file G4WorkerTaskRunManager.cc.

{
  if (verboseLevel > 0 && !fakeRun) {
    timer->Stop();
    // prefix with thread # info due to how TBB calls this function
    G4String prefix = "[thread " + std::to_string(workerContext->GetThreadId()) + "] ";
    G4cout << prefix << "Thread-local run terminated." << G4endl;
    G4cout << prefix << "Run Summary" << G4endl;
    if (runAborted)
      G4cout << prefix << "  Run Aborted after " << numberOfEventProcessed << " events processed."
             << G4endl;
    else
      G4cout << prefix << "  Number of events processed : " << numberOfEventProcessed << G4endl;
    G4cout << prefix << "  " << *timer << G4endl;
  }
}

Referenced by G4TaskRunManagerKernel::TerminateWorkerRunEventLoop().

Member Data Documentation

◆ processedCommandStack

G4StrVector G4WorkerTaskRunManager::processedCommandStack

protected

Definition at line 80 of file G4WorkerTaskRunManager.hh.

Referenced by GetCommandStack(), G4WorkerSubEvtRunManager::ProcessUI(), and ProcessUI().

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

◆ G4StrVector

Constructor & Destructor Documentation

◆ G4WorkerTaskRunManager()

Member Function Documentation

◆ DoCleanup()

◆ DoEventLoop()

◆ DoWork()

◆ GenerateEvent()

◆ GetCommandStack()

◆ GetWorkerRunManager()

◆ GetWorkerRunManagerKernel()

◆ GetWorkerThread()

◆ ProcessOneEvent()

◆ ProcessUI()

◆ RestoreRndmEachEvent()

◆ RunInitialization()

◆ RunTermination()

◆ SetupDefaultRNGEngine()

◆ StoreRNGStatus()

◆ TerminateEventLoop()

Member Data Documentation

◆ processedCommandStack