G4WorkerSubEvtRunManager Class Reference

#include <G4WorkerSubEvtRunManager.hh>

Inheritance diagram for G4WorkerSubEvtRunManager:

Public Member Functions
	G4WorkerSubEvtRunManager (G4int subEventType=0)
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
void	DoCleanup () override
void	ProcessUI () override
void	SetUserInitialization (G4VUserPhysicsList *userPL) override
void	SetUserInitialization (G4VUserDetectorConstruction *userDC) override
void	SetUserInitialization (G4UserWorkerInitialization *userInit) override
void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit) override
void	SetUserInitialization (G4VUserActionInitialization *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
G4int	GetSubEventType () const override
void	SetSubEventType (G4int) override
Public Member Functions inherited from G4WorkerTaskRunManager
	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
G4WorkerThread *	GetWorkerThread () const
G4StrVector	GetCommandStack () const
Public Member Functions inherited from G4WorkerRunManager
	G4WorkerRunManager ()
	~G4WorkerRunManager () override
void	InitializeGeometry () override
void	SetWorkerThread (G4WorkerThread *wc)
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 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 G4WorkerSubEvtRunManager *	GetWorkerRunManager ()
static G4WorkerSubEvtRunManagerKernel *	GetWorkerRunManagerKernel ()
Static Public Member Functions inherited from G4WorkerTaskRunManager
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 G4WorkerTaskRunManager
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 ()

Additional Inherited Members
Public Types inherited from G4WorkerTaskRunManager
using	G4StrVector = std::vector<G4String>
Public Types inherited from G4RunManager
enum	RMType {   sequentialRM , masterRM , workerRM , subEventMasterRM ,   subEventWorkerRM }
Protected Attributes inherited from G4WorkerTaskRunManager
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
Static Protected Attributes inherited from G4RunManager
static G4RUN_DLL G4bool	fGeometryHasBeenDestroyed = false

Detailed Description

Definition at line 51 of file G4WorkerSubEvtRunManager.hh.

Constructor & Destructor Documentation

G4WorkerSubEvtRunManager()

G4WorkerSubEvtRunManager::G4WorkerSubEvtRunManager

(

G4int

subEventType = 0

)

Definition at line 74 of file G4WorkerSubEvtRunManager.cc.

{
  runManagerType = subEventWorkerRM; 
  SetSubEventType(seType);
}

Referenced by GetWorkerRunManager().

Member Function Documentation

DoCleanup()

void G4WorkerSubEvtRunManager::DoCleanup ( )

overridevirtual

Reimplemented from G4WorkerTaskRunManager.

Definition at line 290 of file G4WorkerSubEvtRunManager.cc.

{
  // Nothing to do for a run 
 
  //CleanUpPreviousEvents();
  //
  //delete currentRun;
  //currentRun = nullptr;
}

DoEventLoop()

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

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 170 of file G4WorkerSubEvtRunManager.cc.

{
  // This method is not used in worker sub-event mode
  G4Exception("G4WorkerSubEvtRunManager::DoEventLoop()","SubEvtXXX001",FatalException,
    "This method is not used in the worker thread of sub-event parallel mode");
}

DoWork()

void G4WorkerSubEvtRunManager::DoWork ( )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 302 of file G4WorkerSubEvtRunManager.cc.

{
  if(verboseLevel>1) {
    G4cout << "G4WorkerSubEvtRunManager::DoWork() starts.........." << G4endl;
  }
 
  G4SubEvtRunManager* mrm = G4SubEvtRunManager::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(); }
  }
 
  G4bool reseedRequired = false;
  if (newRun) {
    G4bool cond = ConfirmBeamOnCondition();
    if (cond) {
      ConstructScoringWorlds();
      RunInitialization();
    }
    reseedRequired = true;
  }
 
  assert(workerContext != nullptr);
  workerContext->UpdateGeometryAndPhysicsVectorFromMaster();
 
  eventManager->UseSubEventParallelism(true);
 
  G4bool needMoreWork = true;
  while(needMoreWork)
  {
    G4bool notReady = false;
    G4long s1, s2, s3;
    auto subEv = mrm->GetSubEvent(fSubEventType, notReady, s1, s2, s3, reseedRequired);
    if(subEv==nullptr && notReady)
    {
      // Master is not yet ready for tasking a sub-event. 
      // Wait 1 second and retry.
      G4THREADSLEEP(1);
    }
    else if(subEv==nullptr)
    { 
      // No more sub-event to process
      // Report the results of previous sub-events if any
      G4Event* remainingE = nullptr;
      do
      {
        remainingE = eventManager->RetrieveCompletedSubEvent();
        if(remainingE)
        {
          mrm->SubEventFinished(remainingE->GetSubEvent(),remainingE);
          delete remainingE;
        }
      }
      while(remainingE);
 
      // Check if no more sub-event in event manager
      if(eventManager->GetNumberOfRemainingSubEvents()==0)
      { needMoreWork = false; }
      else
      { // Wait 1 second and revisit.
        G4THREADSLEEP(1);
        if(verboseLevel>1) {
          G4cout << "G4WorkerSubEvtRunManager::DoWork() - " 
                 << eventManager->GetNumberOfRemainingSubEvents()
                 << " sub-events are still incomplete in the event manager."<< G4endl;
        }
      }
    }
    else
    {
      // Let's work for this sub-event.
      if(reseedRequired)
      {
        G4long seeds[3] = {s1, s2, s3};
        G4Random::setTheSeeds(seeds, -1);
        reseedRequired = false;
      }
 
      // create a G4Event object for this sub-event. This G4Event object will contain output
      // to be merged into the master event.
      auto masterEvent = subEv->GetEvent();
      G4Event* ev = new G4Event(masterEvent->GetEventID());
      ev->FlagAsSubEvent(masterEvent,fSubEventType,subEv);
      ++numberOfEventProcessed;
 
      // Create a G4TrackVector as the input
      G4TrackVector* tv = new G4TrackVector();
      for(auto& stackedTrack : *subEv)
      {
        // tracks (and trajectories) stored in G4SubEvent object belong to the master thread
        // and thus they must not be deleted by the worker thread. They must be cloned.
        G4Track* tr = new G4Track();
        tr->CopyTrackInfo(*(stackedTrack.GetTrack()),false);
        tv->push_back(tr);
      }
 
      // Process this sub-event
      currentEvent = ev;
      eventManager->ProcessOneEvent(tv,ev);
 
      // We don't need following two lines, as they are taken care by the master
      //////AnalyzeEvent(ev);
      //////UpdateScoring();
 
      // Report the results to the master if sub-event is completed
      if(subEv->IsCompleted())
      {
        mrm->SubEventFinished(subEv,ev); 
        delete ev;
      }
    
      // Report the results of previous sub-events if any
      G4Event* remainingE = nullptr;
      do 
      {
        remainingE = eventManager->RetrieveCompletedSubEvent(); 
        if(remainingE)
        {
          mrm->SubEventFinished(remainingE->GetSubEvent(),remainingE);
          delete remainingE;
        }
      }
      while(remainingE);
 
      if(verboseLevel>2)
      {
        G4cout << "G4WorkerSubEvtRunManager::DoWork() - " 
               << eventManager->GetNumberOfRemainingSubEvents()
               << " sub-events are still incomplete in the event manager."<< G4endl;
      }
 
      // clean up
      delete tv;
    }
  }
 
  if(verboseLevel>1) {
    G4cout << "G4WorkerSubEvtRunManager::DoWork() completed.........." << G4endl;
  }
    
}

GenerateEvent()

G4Event * G4WorkerSubEvtRunManager::GenerateEvent ( G4int i_event )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 189 of file G4WorkerSubEvtRunManager.cc.

{
  // This method is not used in worker sub-event mode
  G4Exception("G4WorkerSubEvtRunManager::GenerateEvent()","SubEvtXXX003",FatalException,
    "This method is not used in the worker thread of sub-event parallel mode");
  return nullptr;
}

GetSubEventType()

G4int G4WorkerSubEvtRunManager::GetSubEventType ( ) const

inlineoverridevirtual

Reimplemented from G4RunManager.

Definition at line 92 of file G4WorkerSubEvtRunManager.hh.

    { return fSubEventType; }

GetWorkerRunManager()

G4WorkerSubEvtRunManager * G4WorkerSubEvtRunManager::GetWorkerRunManager ( )

static

Definition at line 60 of file G4WorkerSubEvtRunManager.cc.

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

Referenced by GetWorkerRunManagerKernel().

GetWorkerRunManagerKernel()

G4WorkerSubEvtRunManagerKernel * G4WorkerSubEvtRunManager::GetWorkerRunManagerKernel ( )

static

Definition at line 67 of file G4WorkerSubEvtRunManager.cc.

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

ProcessOneEvent()

void G4WorkerSubEvtRunManager::ProcessOneEvent ( G4int i_event )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 180 of file G4WorkerSubEvtRunManager.cc.

{
  // This method is not used in worker sub-event mode
  G4Exception("G4WorkerSubEvtRunManager::ProcessOneEvent()","SubEvtXXX002",FatalException,
    "This method is not used in the worker thread of sub-event parallel mode");
}

ProcessUI()

void G4WorkerSubEvtRunManager::ProcessUI ( )

overridevirtual

Reimplemented from G4WorkerTaskRunManager.

Definition at line 262 of file G4WorkerSubEvtRunManager.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 G4WorkerSubEvtRunManager::RestoreRndmEachEvent ( G4bool flag )

inlineoverridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 67 of file G4WorkerSubEvtRunManager.hh.

{ readStatusFromFile = flag; }

RunInitialization()

void G4WorkerSubEvtRunManager::RunInitialization ( )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 80 of file G4WorkerSubEvtRunManager.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;
  if(verboseLevel > 0) timer->Start();
}

Referenced by DoWork().

RunTermination()

void G4WorkerSubEvtRunManager::RunTermination ( )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 199 of file G4WorkerSubEvtRunManager.cc.

{
  if (!fakeRun && (currentRun != nullptr)) {
    MergePartialResults(true);
 
    // 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();
}

SetSubEventType()

void G4WorkerSubEvtRunManager::SetSubEventType ( G4int ty )

overridevirtual

Reimplemented from G4RunManager.

Definition at line 448 of file G4WorkerSubEvtRunManager.cc.

{
  auto* mrm = G4SubEvtRunManager::GetMasterRunManager();
  mrm->RegisterSubEvtWorker(this,ty);
  fSubEventType = ty;
}

Referenced by G4WorkerSubEvtRunManager().

SetupDefaultRNGEngine()

void G4WorkerSubEvtRunManager::SetupDefaultRNGEngine ( )

overrideprotectedvirtual

Reimplemented from G4WorkerRunManager.

Definition at line 241 of file G4WorkerSubEvtRunManager.cc.

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

SetUserAction() [1/6]

void G4WorkerSubEvtRunManager::SetUserAction ( G4UserEventAction * userAction )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 501 of file G4WorkerSubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserAction() [2/6]

void G4WorkerSubEvtRunManager::SetUserAction ( G4UserRunAction * userAction )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 492 of file G4WorkerSubEvtRunManager.cc.

{
  G4Exception("G4WorkerSubEvtRunManager::SetUserAction(G4UserRunAction*)", "RunSE0221",
              FatalException, "This method should be used only with an instance of the master thread");
}

SetUserAction() [3/6]

void G4WorkerSubEvtRunManager::SetUserAction ( G4UserStackingAction * userAction )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 514 of file G4WorkerSubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserAction() [4/6]

void G4WorkerSubEvtRunManager::SetUserAction ( G4UserSteppingAction * userAction )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 526 of file G4WorkerSubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserAction() [5/6]

void G4WorkerSubEvtRunManager::SetUserAction ( G4UserTrackingAction * userAction )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 520 of file G4WorkerSubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserAction() [6/6]

void G4WorkerSubEvtRunManager::SetUserAction ( G4VUserPrimaryGeneratorAction * userAction )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 507 of file G4WorkerSubEvtRunManager.cc.

{
  G4Exception("G4WorkerSubEvtRunManager::SetUserAction(G4VUserPrimaryGeneratorAction*)", "RunSE0223",
              FatalException, "This method should be used only with an instance of the master thread");
}

SetUserInitialization() [1/5]

void G4WorkerSubEvtRunManager::SetUserInitialization ( G4UserWorkerInitialization * userInit )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 457 of file G4WorkerSubEvtRunManager.cc.

{
  G4Exception("G4WorkerSubEvtRunManager::SetUserInitialization(G4UserWorkerInitialization*)", "RunSE0118",
              FatalException, "This method should be used only with an instance of the master thread");
}

SetUserInitialization() [2/5]

void G4WorkerSubEvtRunManager::SetUserInitialization ( G4UserWorkerThreadInitialization * userInit )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 464 of file G4WorkerSubEvtRunManager.cc.

{
  G4Exception("G4WorkerSubEvtRunManager::SetUserInitialization(G4UserWorkerThreadInitialization*)", "RunSE0119",
              FatalException, "This method should be used only with an instance of the master thread");
}

SetUserInitialization() [3/5]

void G4WorkerSubEvtRunManager::SetUserInitialization ( G4VUserActionInitialization * userInit )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 471 of file G4WorkerSubEvtRunManager.cc.

{
  G4Exception("G4WorkerSubEvtRunManager::SetUserInitialization(G4VUserActionInitialization*)", "RunSE0120",
              FatalException, "This method should be used only with an instance of the master thread");
}

SetUserInitialization() [4/5]

void G4WorkerSubEvtRunManager::SetUserInitialization ( G4VUserDetectorConstruction * userDC )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 478 of file G4WorkerSubEvtRunManager.cc.

{
  G4Exception("G4WorkerSubEvtRunManager::SetUserInitialization(G4VUserDetectorConstruction*)", "RunSE0121",
              FatalException, "This method should be used only with an instance of the master thread");
}

SetUserInitialization() [5/5]

void G4WorkerSubEvtRunManager::SetUserInitialization ( G4VUserPhysicsList * userPL )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 485 of file G4WorkerSubEvtRunManager.cc.

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

StoreRNGStatus()

void G4WorkerSubEvtRunManager::StoreRNGStatus ( const G4String & filenamePrefix )

overrideprotectedvirtual

Reimplemented from G4WorkerRunManager.

Definition at line 253 of file G4WorkerSubEvtRunManager.cc.

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

Referenced by RunInitialization().

TerminateEventLoop()

void G4WorkerSubEvtRunManager::TerminateEventLoop ( )

overridevirtual

Reimplemented from G4WorkerRunManager.

Definition at line 222 of file G4WorkerSubEvtRunManager.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 << " sub-events processed."
             << G4endl;
    else
      G4cout << prefix << "  Number of sub-events processed : " << numberOfEventProcessed << G4endl;
    G4cout << prefix << "  " << *timer << G4endl;
  }
}

---

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

• G4WorkerSubEvtRunManager.hh
• G4WorkerSubEvtRunManager.cc