G4SubEvtRunManager Class Reference

#include <G4SubEvtRunManager.hh>

Inheritance diagram for G4SubEvtRunManager:

Public Member Functions
	G4SubEvtRunManager (G4bool useTBB=G4GetEnv< G4bool >("G4USE_TBB", false))
	G4SubEvtRunManager (G4VUserTaskQueue *taskQueue, G4bool useTBB=G4GetEnv< G4bool >("G4USE_TBB", false), G4int evtGrainsize=0)
	~G4SubEvtRunManager () override
void	Initialize () override
void	Initialize (uint64_t nthreads) override
void	RunInitialization () override
void	InitializeEventLoop (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1) override
void	TerminateOneEvent () override
void	ProcessOneEvent (G4int i_event) override
void	ConstructScoringWorlds () override
void	RunTermination () override
void	CleanUpPreviousEvents () override
G4bool	SetUpAnEvent (G4Event *, G4long &, G4long &, G4long &, G4bool=true) override
G4int	SetUpNEvents (G4Event *, G4SeedsQueue *, G4bool=true) override
void	RegisterSubEventType (G4int ty, G4int maxEnt) override
void	RegisterSubEvtWorker (G4WorkerSubEvtRunManager *, G4int)
const G4SubEvent *	GetSubEvent (G4int ty, G4bool &notReady, G4long &s1, G4long &s2, G4long &s3, G4bool reseedRequired=true) override
void	SubEventFinished (const G4SubEvent *se, const G4Event *evt) override
void	MergeScores (const G4ScoringManager *localScoringManager) override
void	MergeRun (const G4Run *) override
std::size_t	GetNumberActiveThreads () const 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
void	RequestWorkersProcessCommandsStack () override
void	ThisWorkerProcessCommandsStackDone () override
void	WaitForReadyWorkers () override
void	WaitForEndEventLoopWorkers () override
WorkerActionRequest	ThisWorkerWaitForNextAction () override
void	AbortRun (G4bool softAbort=false) override
void	AbortEvent () override
void	TrajectoriesToBeMerged (G4bool val=true) override
Public Member Functions inherited from G4TaskRunManager
	G4TaskRunManager (G4bool useTBB=G4GetEnv< G4bool >("G4USE_TBB", false))
	G4TaskRunManager (G4VUserTaskQueue *taskQueue, G4bool useTBB=G4GetEnv< G4bool >("G4USE_TBB", false), G4int evtGrainsize=0)
	~G4TaskRunManager () override
void	SetGrainsize (G4int n)
G4int	GetGrainsize () const
G4int	GetNumberOfTasks () const
G4int	GetNumberOfEventsPerTask () const
void	SetNumberOfThreads (G4int n) override
G4int	GetNumberOfThreads () const override
size_t	GetNumberActiveThreads () const override
void	Initialize () override
void	InitializeEventLoop (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1) override
void	InitializeThreadPool () override
G4bool	ThreadPoolIsInitialized () const
void	Initialize (uint64_t nthreads) override
void	TerminateOneEvent () override
void	ProcessOneEvent (G4int i_event) override
void	ConstructScoringWorlds () override
void	RunTermination () override
G4bool	SetUpAnEvent (G4Event *, G4long &s1, G4long &s2, G4long &s3, G4bool reseedRequired=true) override
G4int	SetUpNEvents (G4Event *, G4SeedsQueue *seedsQueue, G4bool reseedRequired=true) override
void	MergeScores (const G4ScoringManager *localScoringManager) override
void	MergeRun (const G4Run *localRun) override
void	RequestWorkersProcessCommandsStack () override
void	ThisWorkerProcessCommandsStackDone () override
void	WaitForReadyWorkers () override
void	WaitForEndEventLoopWorkers () override
void	ThisWorkerReady () override
void	ThisWorkerEndEventLoop () override
WorkerActionRequest	ThisWorkerWaitForNextAction () override
void	SetInitializeSeedsCallback (InitializeSeedsCallback f)
void	AbortRun (G4bool softAbort=false) override
void	AbortEvent () override
Public Member Functions inherited from G4MTRunManager
	G4MTRunManager ()
	~G4MTRunManager () override
void	SetPinAffinity (G4int n=1)
G4int	GetPinAffinity () const
std::vector< G4String >	GetCommandStack ()
const CLHEP::HepRandomEngine *	getMasterRandomEngine () const
void	SetEventModulo (G4int i=1)
G4int	GetEventModulo () const
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	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
virtual void	InitializeGeometry ()
virtual void	InitializePhysics ()
virtual G4bool	ConfirmBeamOnCondition ()
virtual void	DoEventLoop (G4int n_event, const char *macroFile=nullptr, G4int n_select=-1)
virtual void	TerminateEventLoop ()
virtual G4Event *	GenerateEvent (G4int i_event)
virtual void	AnalyzeEvent (G4Event *anEvent)
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)
virtual void	RestoreRndmEachEvent (G4bool)
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 G4int	GetSubEventType () const
virtual void	SetSubEventType (G4int)
virtual std::size_t	GetMaxNTrack () const
virtual void	ReportEventDeletion (const G4Event *evt)
void	ResetNavigatorAtInitialization (G4bool val=true)
Public Member Functions inherited from PTL::TaskRunManager
	TaskRunManager (bool useTBB=false)
virtual	~TaskRunManager ()
virtual void	Terminate ()
ThreadPool *	GetThreadPool () const
TaskManager *	GetTaskManager () const
bool	IsInitialized () const

Static Public Member Functions
static G4SubEvtRunManager *	GetMasterRunManager ()
Static Public Member Functions inherited from G4TaskRunManager
static G4TaskRunManager *	GetMasterRunManager ()
static G4TaskRunManagerKernel *	GetMTMasterRunManagerKernel ()
static G4ThreadId	GetMasterThreadId ()
Static Public Member Functions inherited from G4MTRunManager
static G4ThreadId	GetMasterThreadId ()
static G4ScoringManager *	GetMasterScoringManager ()
static masterWorlds_t &	GetMasterWorlds ()
static void	addWorld (G4int counter, G4VPhysicalVolume *w)
static G4MTRunManager *	GetMasterRunManager ()
static G4RunManagerKernel *	GetMasterRunManagerKernel ()
static G4MTRunManagerKernel *	GetMTMasterRunManagerKernel ()
static G4int	SeedOncePerCommunication ()
static void	SetSeedOncePerCommunication (G4int val)
Static Public Member Functions inherited from G4RunManager
static G4RunManager *	GetRunManager ()
static G4bool	IfGeometryHasBeenDestroyed ()
Static Public Member Functions inherited from PTL::TaskRunManager
static TaskRunManager *	GetInstance (bool useTBB=false)
static TaskRunManager *	GetMasterRunManager (bool useTBB=false)

Protected Member Functions
void	ComputeNumberOfTasks () override
G4bool	InitializeSeeds (G4int) override
void	RefillSeeds () override
void	CreateAndStartWorkers () override
void	TerminateWorkers () override
void	NewActionRequest (WorkerActionRequest) override
void	AddEventTask (G4int) override
void	SetUpSeedsForSubEvent (G4long &s1, G4long &s2, G4long &s3)
void	MergeTrajectories (const G4SubEvent *se, const G4Event *evt) override
void	UpdateScoringForSubEvent (const G4SubEvent *se, const G4Event *evt) override
void	CleanUpUnnecessaryEvents (G4int keepNEvents) override
void	StackPreviousEvent (G4Event *anEvent) override
Protected Member Functions inherited from G4TaskRunManager
G4bool	InitializeSeeds (G4int) override
void	RefillSeeds () override
void	StoreRNGStatus (const G4String &filenamePrefix) override
void	CreateAndStartWorkers () override
void	TerminateWorkers () override
void	NewActionRequest (WorkerActionRequest) override
Protected Member Functions inherited from G4MTRunManager
virtual void	PrepareCommandsStack ()
void	rndmSaveThisRun () override
void	rndmSaveThisEvent () override
Protected Member Functions inherited from G4RunManager
	G4RunManager (RMType rmType)
void	UpdateScoring (const G4Event *evt=nullptr)
virtual void	DeleteUserInitializations ()

Protected Attributes
std::atomic< G4bool >	runInProgress = false
Protected Attributes inherited from G4TaskRunManager
RunTaskGroup *	workTaskGroup = nullptr
G4bool &	poolInitialized = PTL::TaskRunManager::m_is_initialized
G4ThreadPool *&	threadPool = PTL::TaskRunManager::m_thread_pool
G4VUserTaskQueue *&	taskQueue = PTL::TaskRunManager::m_task_queue
G4TaskManager *&	taskManager = PTL::TaskRunManager::m_task_manager
InitializeSeedsCallback	initSeedsCallback
G4bool	workersStarted = false
G4int	eventGrainsize = 0
G4int	numberOfEventsPerTask = -1
G4int	numberOfTasks = -1
CLHEP::HepRandomEngine *	masterRNGEngine = nullptr
G4TaskRunManagerKernel *	MTkernel = nullptr
Protected Attributes inherited from G4MTRunManager
G4int	nworkers = 2
G4int	forcedNwokers = -1
G4int	numberOfEventToBeProcessed = 0
WorkerActionRequest	nextActionRequest = WorkerActionRequest::UNDEFINED
G4int	eventModuloDef = 0
G4int	eventModulo = 1
G4int	nSeedsUsed = 0
G4int	nSeedsFilled = 0
G4int	nSeedsMax = 10000
G4int	nSeedsPerEvent = 2
G4double *	randDbl = nullptr
G4MTBarrier	beginOfEventLoopBarrier
G4MTBarrier	endOfEventLoopBarrier
G4MTBarrier	nextActionRequestBarrier
G4MTBarrier	processUIBarrier
G4int	pinAffinity = 0
G4ThreadsList	threads
std::vector< G4String >	uiCmdsForWorkers
CLHEP::HepRandomEngine *	masterRNGEngine = nullptr
G4MTRunManagerKernel *	MTkernel = nullptr
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
Protected Attributes inherited from PTL::TaskRunManager
bool	m_is_initialized = false
uint64_t	m_workers = 0
bool	m_use_tbb = false
VUserTaskQueue *	m_task_queue = nullptr
ThreadPool *	m_thread_pool = nullptr
TaskManager *	m_task_manager = nullptr

Friends
class	G4RunManagerFactory

Additional Inherited Members
Public Types inherited from G4TaskRunManager
using	InitializeSeedsCallback = std::function<G4bool(G4int, G4int&, G4int&)>
using	RunTaskGroup = G4TaskGroup<void>
Public Types inherited from G4MTRunManager
enum class	WorkerActionRequest { UNDEFINED , NEXTITERATION , PROCESSUI , ENDWORKER }
using	masterWorlds_t = std::map<G4int, G4VPhysicalVolume*>
Public Types inherited from G4RunManager
enum	RMType {   sequentialRM , masterRM , workerRM , subEventMasterRM ,   subEventWorkerRM }
Public Types inherited from PTL::TaskRunManager
using	pointer = TaskRunManager*
Protected Types inherited from G4MTRunManager
using	G4ThreadsList = std::list<G4Thread*>
Static Protected Attributes inherited from G4MTRunManager
static G4MTRUN_DLL G4ScoringManager *	masterScM = nullptr
static G4MTRUN_DLL G4MTRunManager *	fMasterRM = nullptr
static G4ThreadId	masterThreadId = G4ThisThread::get_id()
static G4int	seedOncePerCommunication = 0
Static Protected Attributes inherited from G4RunManager
static G4RUN_DLL G4bool	fGeometryHasBeenDestroyed = false

Detailed Description

Definition at line 49 of file G4SubEvtRunManager.hh.

Constructor & Destructor Documentation

G4SubEvtRunManager() [1/2]

G4SubEvtRunManager::G4SubEvtRunManager

(

G4bool

useTBB = G4GetEnv<G4bool>("G4USE_TBB", false)

)

Definition at line 86 of file G4SubEvtRunManager.cc.

 : G4SubEvtRunManager(nullptr, useTBB, 0)
{ runManagerType = subEventMasterRM; }

Referenced by G4SubEvtRunManager(), and GetMasterRunManager().

G4SubEvtRunManager() [2/2]

G4SubEvtRunManager::G4SubEvtRunManager	(	G4VUserTaskQueue *	taskQueue,
		G4bool	useTBB = G4GetEnv<G4bool>("G4USE_TBB", false),
		G4int	evtGrainsize = 0 )

Definition at line 76 of file G4SubEvtRunManager.cc.

 : G4TaskRunManager(task_queue, useTBB, grainsize)
{
  runManagerType = subEventMasterRM;
  G4UImanager::GetUIpointer()->SetAlias("RunMode subEventParallel");
}

~G4SubEvtRunManager()

G4SubEvtRunManager::~G4SubEvtRunManager ( )

override

Definition at line 92 of file G4SubEvtRunManager.cc.

{
  // relying all the necessary deletion upon the base class
  // G4TaskRunManager::~G4TaskRunManager()
}

Member Function Documentation

AbortEvent()

void G4SubEvtRunManager::AbortEvent ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 814 of file G4SubEvtRunManager.cc.

{
  // nothing to do in the master thread
}

AbortRun()

void G4SubEvtRunManager::AbortRun ( G4bool softAbort = false )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 799 of file G4SubEvtRunManager.cc.

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

AddEventTask()

void G4SubEvtRunManager::AddEventTask ( G4int nt )

overrideprotectedvirtual

Reimplemented from G4TaskRunManager.

Definition at line 353 of file G4SubEvtRunManager.cc.

{
  if (verboseLevel > 3) G4cout << "Adding task " << nt << " to task-group..." << G4endl;
  workTaskGroup->exec([]() { G4TaskRunManagerKernel::ExecuteWorkerTask(); });
}

Referenced by CreateAndStartWorkers().

CleanUpPreviousEvents()

void G4SubEvtRunManager::CleanUpPreviousEvents ( )

overridevirtual

Reimplemented from G4RunManager.

Definition at line 742 of file G4SubEvtRunManager.cc.

{
  // Delete all events carried over from previous run.
  // This method is invoked at the beginning of the next run
  // or from the destructor of G4RunManager at the very end of
  // the program.
  auto evItr = previousEvents->cbegin();
  while (evItr != previousEvents->cend()) {
    G4Event* evt = *evItr;
    if (evt != nullptr)
    {
      ReportEventDeletion(evt);
      // remove evt from the event vector of G4Run as well
      if(currentRun!=nullptr)
      {
        auto eventVector = currentRun->GetEventVector();
        auto eItr = std::find(eventVector->cbegin(),eventVector->cend(),evt);
        if(eItr != eventVector->cend()) eventVector->erase(eItr);
      }
      delete evt;
    }
    evItr = previousEvents->erase(evItr);
  }
  if(currentRun!=nullptr)
  {
    auto eventVector = currentRun->GetEventVector();
    if(eventVector==nullptr || eventVector->empty()) return;
    auto eItr = eventVector->cbegin();
    while(eItr != eventVector->cend())
    {
      const G4Event* ev = *eItr;
      if(ev!=nullptr)
      {
        ReportEventDeletion(ev);
        delete ev;
      }
      eItr = eventVector->erase(eItr);
    }
  }
}

CleanUpUnnecessaryEvents()

void G4SubEvtRunManager::CleanUpUnnecessaryEvents ( G4int keepNEvents )

overrideprotectedvirtual

Reimplemented from G4RunManager.

Definition at line 199 of file G4SubEvtRunManager.cc.

{
  // Delete events that are no longer necessary for post
  // processing such as visualization.
  // N.B. If ToBeKept() is true, the pointer of this event is
  // kept in G4Run, and deleted along with the deletion of G4Run.
 
  if(keepNEvents>0) {
    G4ExceptionDescription ed;
    ed << "G4RunManager::SetNumberOfEventsToBeStored() is not supported in sub-event parallel mode.\n"
       << "User may still keep events bu G4EventManager::KeepTheCurrentEvent()";
    G4Exception("G4SubEvtRunManager::CleanUpUnnecessaryEvents","SubEvtRM1201",FatalException,ed);
    return;
  }
 
  assert(currentRun!=nullptr);
 
  auto eventVector = currentRun->GetEventVector();
  if(eventVector==nullptr || eventVector->empty()) return;
  auto eItr = eventVector->cbegin();
  while(eItr != eventVector->cend())
  {
    const G4Event* ev = *eItr;
    if(ev!=nullptr)
    {
      if(!(ev->IsEventCompleted()))
      {
        if(ev->GetNumberOfRemainingSubEvents()==0)
        { // This event has been completed since last time we were here
          ev->EventCompleted();
          if(userEventAction!=nullptr) userEventAction->EndOfEventAction(ev);
          auto pVisManager = G4VVisManager::GetConcreteInstance();
          if (pVisManager) pVisManager->EventReadyForVis(ev);
          UpdateScoring(ev);
          if(ev->ToBeKept() || ev->GetNumberOfGrips()>0) 
          { // we keep this event for post-processing (i.e. for vis)
            eItr++;
          }
          else
          { // this event is no longer needed
            ReportEventDeletion(ev);
            delete ev;
            eItr = eventVector->erase(eItr);
          }
        }
        else
        { // this event is still incomplete
          eItr++;
        }
      }
      else if(ev->ToBeKept() || ev->GetNumberOfGrips()>0) 
      { // we still need this event
        eItr++;
      }
      else
      { // post-processing done. we no longer need this event
        ReportEventDeletion(ev);
        delete ev;
        eItr = eventVector->erase(eItr);
      } 
    }
    else
    { // ev is a null pointer 
      eItr = eventVector->erase(eItr);
    }
  }   
}

Referenced by RunTermination(), and StackPreviousEvent().

ComputeNumberOfTasks()

void G4SubEvtRunManager::ComputeNumberOfTasks ( )

inlineoverrideprotectedvirtual

Reimplemented from G4TaskRunManager.

Definition at line 165 of file G4SubEvtRunManager.hh.

    {
      // This method is not used for sub-event parallel mode
      numberOfTasks = (G4int)threadPool->size();
      numberOfEventsPerTask = -1;
      eventModulo = -1;
    }

Referenced by CreateAndStartWorkers(), and InitializeEventLoop().

ConstructScoringWorlds()

void G4SubEvtRunManager::ConstructScoringWorlds ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 506 of file G4SubEvtRunManager.cc.

{
  masterScM = G4ScoringManager::GetScoringManagerIfExist();
  // Call base class stuff...
  G4RunManager::ConstructScoringWorlds();
 
  GetMasterWorlds().clear();
  auto nWorlds = (G4int)G4TransportationManager::GetTransportationManager()->GetNoWorlds();
  auto itrW = G4TransportationManager::GetTransportationManager()->GetWorldsIterator();
  for (G4int iWorld = 0; iWorld < nWorlds; ++iWorld) {
    addWorld(iWorld, *itrW);
    ++itrW;
  }
}

CreateAndStartWorkers()

void G4SubEvtRunManager::CreateAndStartWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 269 of file G4SubEvtRunManager.cc.

{
  // Now loop on requested number of workers
  // This will also start the workers
  // Currently we do not allow to change the
  // number of threads: threads area created once
  // Instead of pthread based workers, create tbbTask
  static G4bool initializeStarted = false;
 
  ComputeNumberOfTasks();
 
  if (fakeRun) {
    if (initializeStarted) {
      auto initCmdStack = GetCommandStack();
      if (!initCmdStack.empty()) {
        threadPool->execute_on_all_threads([cmds = std::move(initCmdStack)]() {
          for (auto& itr : cmds)
            G4UImanager::GetUIpointer()->ApplyCommand(itr);
          G4WorkerTaskRunManager::GetWorkerRunManager()->DoWork();
        });
      }
    }
    else {
      if (verboseLevel > 0) {
        std::stringstream msg;
        msg << "--> G4SubEvtRunManager::CreateAndStartWorkers() --> "
            << "Initializing workers...";
 
        std::stringstream ss;
        ss.fill('=');
        ss << std::setw((G4int)msg.str().length()) << "";
        G4cout << "\n" << ss.str() << "\n" << msg.str() << "\n" << ss.str() << "\n" << G4endl;
      }
 
      G4TaskRunManagerKernel::InitCommandStack() = GetCommandStack();
      threadPool->execute_on_all_threads([]() { G4TaskRunManagerKernel::InitializeWorker(); });
    }
    initializeStarted = true;
  }
  else {
    auto initCmdStack = GetCommandStack();
    if (!initCmdStack.empty()) {
      threadPool->execute_on_all_threads([cmds = std::move(initCmdStack)]() {
        for (auto& itr : cmds)
          G4UImanager::GetUIpointer()->ApplyCommand(itr);
      });
    }
 
    // cleans up a previous run and events in case a thread
    // does not execute any tasks
    threadPool->execute_on_all_threads([]() { G4TaskRunManagerKernel::ExecuteWorkerInit(); });
 
    if (verboseLevel > 0) {
      std::stringstream msg;
      msg << "--> G4SubEvtRunManager::CreateAndStartWorkers() --> "
          << "Creating " << numberOfTasks << " tasks with " << numberOfEventsPerTask
          << " events/task...";
 
      std::stringstream ss;
      ss.fill('=');
      ss << std::setw((G4int)msg.str().length()) << "";
      G4cout << "\n" << ss.str() << "\n" << msg.str() << "\n" << ss.str() << "\n" << G4endl;
    }
 
    /* TODO (PHASE-II): Better calculation of task/event/subevents
       Currently, number of tasks is equal to number of threads
       and each task has a loop that endlessly asks for next sub-event
       until no additional sub-event is available in the master.
       This is not ideal. We should make each task work only for some limited 
       number of sub-events, and create as many number of tasks as needed
       on the fly during the event loop of the master thread., e.g.
    G4int remaining = numberOfEventToBeProcessed;
    for (G4int nt = 0; nt < numberOfTasks + 1; ++nt) {
      if (remaining > 0) AddEventTask(nt);
      remaining -= numberOfEventsPerTask;
    }
    */
    for(G4int nt = 0; nt < numberOfTasks; ++nt)
    { AddEventTask(nt); }
  }
}

Referenced by InitializeEventLoop().

GetMasterRunManager()

G4SubEvtRunManager * G4SubEvtRunManager::GetMasterRunManager ( )

inlinestatic

Definition at line 54 of file G4SubEvtRunManager.hh.

    {
      auto* _rm = G4MTRunManager::GetMasterRunManager();
      return dynamic_cast<G4SubEvtRunManager*>(_rm);
    }

Referenced by G4WorkerSubEvtRunManager::DoWork(), and G4WorkerSubEvtRunManager::SetSubEventType().

GetNumberActiveThreads()

std::size_t G4SubEvtRunManager::GetNumberActiveThreads ( ) const

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 117 of file G4SubEvtRunManager.hh.

    { return threads.size(); }

GetSubEvent()

const G4SubEvent * G4SubEvtRunManager::GetSubEvent ( G4int ty, G4bool & notReady, G4long & s1, G4long & s2, G4long & s3, G4bool reseedRequired = true )

overridevirtual

Reimplemented from G4RunManager.

Definition at line 529 of file G4SubEvtRunManager.cc.

{
  G4AutoLock l(&accessSubEventMutex);
 
// This method is invoked from the worker, the ownership of G4SubEvent object
// remains to the master, i.e. will be deleted by the master thread through
// TerminateSubEvent() method.
 
  if(currentRun==nullptr)
  {
  // Run has not yet started.
    notReady = true;
    return nullptr;
  }
 
  auto eventVector = currentRun->GetEventVector();
  // RACE HERE: against:
  // 1 G4Run::StoreEvent(G4Event*) G4Run.cc:80
  // 2 G4RunManager::StackPreviousEvent(G4Event*) G4RunManager.cc:572
  for(auto& ev : *eventVector)
  {
  // looping over stored events
    // RACE HERE: against:
    // 1 G4Run::StoreEvent(G4Event*) G4Run.cc:80 
    // 2 G4RunManager::StackPreviousEvent(G4Event*) G4RunManager.cc:572 
    auto se = const_cast<G4Event*>(ev)->PopSubEvent(ty);
    if(se!=nullptr)
    {
    // Sub-event is found in an event that is already finished its event-loop
      notReady = false;
      if(reseedRequired) SetUpSeedsForSubEvent(s1,s2,s3);
      return se;
    }
  }
 
  auto sep = eventManager->PopSubEvent(ty);
  if(sep!=nullptr)
  {
  // Sub-event is found in an event that is still in the event loop
    notReady = false;
    if(reseedRequired) SetUpSeedsForSubEvent(s1,s2,s3);
    return sep;
  } else {
  // No sub-event available
    // RACE HERE vs line 345
    if(runInProgress)
    {
    // Run is still in progress. Worker should wait until a sub-event is ready
      notReady = true;
    }
    else
    {
    // Run is over. No more sub-event to come unless new run starts.
      notReady = false;
    }
    return nullptr;
  }
}

Referenced by G4WorkerSubEvtRunManager::DoWork().

Initialize() [1/2]

void G4SubEvtRunManager::Initialize ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 100 of file G4SubEvtRunManager.cc.

{
  SetSeedOncePerCommunication(1);
  G4bool firstTime = (threadPool == nullptr);
  if (firstTime) G4TaskRunManager::InitializeThreadPool();
 
  G4RunManager::Initialize();
 
  // make sure all worker threads are set up.
  G4RunManager::BeamOn(0);
  if (firstTime) G4RunManager::SetRunIDCounter(0);
  // G4UImanager::GetUIpointer()->SetIgnoreCmdNotFound(true);
}

Initialize() [2/2]

void G4SubEvtRunManager::Initialize ( uint64_t nthreads )

inlineoverridevirtual

Reimplemented from PTL::TaskRunManager.

Definition at line 67 of file G4SubEvtRunManager.hh.

{ PTL::TaskRunManager::Initialize(nthreads); }

InitializeEventLoop()

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

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 385 of file G4SubEvtRunManager.cc.

{
  MTkernel->SetUpDecayChannels();
  numberOfEventToBeProcessed = n_event;
  numberOfEventProcessed = 0;
 
  if (!fakeRun) {
    nSeedsUsed = 0;
    nSeedsFilled = 0;
 
    if (verboseLevel > 0) timer->Start();
 
    n_select_msg = n_select;
    if (macroFile != nullptr) {
      if (n_select_msg < 0) n_select_msg = n_event;
 
      msgText = "/control/execute ";
      msgText += macroFile;
      selectMacro = macroFile;
    }
    else {
      n_select_msg = -1;
      selectMacro = "";
    }
 
    ComputeNumberOfTasks();
 
    // initialize seeds
    // If user did not implement InitializeSeeds,
    // use default: nSeedsPerEvent seeds per event
 
    if (n_event > 0) {
      G4bool _overload = InitializeSeeds(n_event);
      G4bool _functor = false;
      if (!_overload) _functor = initSeedsCallback(n_event, nSeedsPerEvent, nSeedsFilled);
      if (!_overload && !_functor) {
        G4RNGHelper* helper = G4RNGHelper::GetInstance();
        switch (SeedOncePerCommunication()) {
          case 1:
            nSeedsFilled = nworkers;
            break;
          default:
            G4ExceptionDescription msgd;
            msgd << "Parameter value <" << SeedOncePerCommunication()
                 << "> of seedOncePerCommunication is invalid. It is reset "
                    "to 1.";
            G4Exception("G4SubEvtRunManager::InitializeEventLoop()", "Run10036", JustWarning, msgd);
            SetSeedOncePerCommunication(1);
            nSeedsFilled = nworkers;
        }
 
        // Generates up to nSeedsMax seed pairs only.
        if (nSeedsFilled > nSeedsMax) nSeedsFilled = nSeedsMax;
        masterRNGEngine->flatArray(nSeedsPerEvent * nSeedsFilled, randDbl);
        helper->Fill(randDbl, nSeedsFilled, n_event, nSeedsPerEvent);
      }
    }
  }
 
  // Now initialize workers. Check if user defined a WorkerThreadInitialization
  if (userWorkerThreadInitialization == nullptr)
    userWorkerThreadInitialization = new G4UserSubEvtThreadInitialization();
 
  // Prepare UI commands for threads
  PrepareCommandsStack();
 
  // Start worker threads
  CreateAndStartWorkers();
}

InitializeSeeds()

G4bool G4SubEvtRunManager::InitializeSeeds ( G4int )

inlineoverrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 177 of file G4SubEvtRunManager.hh.

{ return false; };

Referenced by InitializeEventLoop().

MergeRun()

void G4SubEvtRunManager::MergeRun ( const G4Run * )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 110 of file G4SubEvtRunManager.hh.

    {}

MergeScores()

void G4SubEvtRunManager::MergeScores ( const G4ScoringManager * localScoringManager )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 523 of file G4SubEvtRunManager.cc.

{
  G4AutoLock l(&scorerMergerMutex);
  if (masterScM != nullptr) masterScM->Merge(localScoringManager);
}

MergeTrajectories()

void G4SubEvtRunManager::MergeTrajectories ( const G4SubEvent * se, const G4Event * evt )

overrideprotectedvirtual

Reimplemented from G4RunManager.

Definition at line 680 of file G4SubEvtRunManager.cc.

{
  auto masterEvt = se->GetEvent();
  auto* trajVector = evt->GetTrajectoryContainer()->GetVector();
  auto* masterTrajContainer = masterEvt->GetTrajectoryContainer();
  if(masterTrajContainer==nullptr) 
  {
    masterTrajContainer = new G4TrajectoryContainer;
    masterEvt->SetTrajectoryContainer(masterTrajContainer);
  }
  for(auto& traj : *trajVector)
  {
    if(traj!=nullptr) {
      auto* cloned = traj->CloneForMaster();
      masterTrajContainer->push_back(cloned);
    }
  }
}

Referenced by SubEventFinished().

NewActionRequest()

void G4SubEvtRunManager::NewActionRequest ( WorkerActionRequest )

inlineoverrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 188 of file G4SubEvtRunManager.hh.

{}

ProcessOneEvent()

void G4SubEvtRunManager::ProcessOneEvent ( G4int i_event )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 125 of file G4SubEvtRunManager.cc.

{
  currentEvent = GenerateEvent(i_event);
  eventManager->ProcessOneEvent(currentEvent);
  
  // Following two lines should not be executed here, as spawned sub-events may 
  // be still being processed. These methods are invoked when all sub-events belongings
  // to this event are processed and scores of these sub-events are marged to the
  // corresponding master event.
  //AnalyzeEvent(currentEvent);
  //UpdateScoring();
 
  if (i_event < n_select_msg) G4UImanager::GetUIpointer()->ApplyCommand(msgText);
}

RefillSeeds()

void G4SubEvtRunManager::RefillSeeds ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 361 of file G4SubEvtRunManager.cc.

{
  G4RNGHelper* helper = G4RNGHelper::GetInstance();
  G4int nFill = 0;
  switch (SeedOncePerCommunication()) {
    case 0:
      nFill = numberOfEventToBeProcessed - nSeedsFilled;
      break;
    case 1:
      nFill = numberOfTasks - nSeedsFilled;
      break;
    case 2:
    default:
      nFill = (numberOfEventToBeProcessed - nSeedsFilled * eventModulo) / eventModulo + 1;
  }
  // Generates up to nSeedsMax seed pairs only.
  if (nFill > nSeedsMax) nFill = nSeedsMax;
  masterRNGEngine->flatArray(nSeedsPerEvent * nFill, randDbl);
  helper->Refill(randDbl, nFill);
  nSeedsFilled += nFill;
}

Referenced by SetUpSeedsForSubEvent().

RegisterSubEventType()

void G4SubEvtRunManager::RegisterSubEventType ( G4int ty, G4int maxEnt )

overridevirtual

Reimplemented from G4RunManager.

Definition at line 856 of file G4SubEvtRunManager.cc.

{
  G4AutoLock l(&registerSubEvtWorkerMutex);
  fSubEvtTypeMap[ty] = maxEnt;
  eventManager->UseSubEventParallelism();
  eventManager->GetStackManager()->RegisterSubEventType(ty,maxEnt);
}

RegisterSubEvtWorker()

void G4SubEvtRunManager::RegisterSubEvtWorker	(	G4WorkerSubEvtRunManager *	wrm,
		G4int	typ )

Definition at line 864 of file G4SubEvtRunManager.cc.

{
  G4AutoLock l(&registerSubEvtWorkerMutex);
  fWorkerMap[wrm] = typ;
}

RequestWorkersProcessCommandsStack()

void G4SubEvtRunManager::RequestWorkersProcessCommandsStack ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 833 of file G4SubEvtRunManager.cc.

{
  PrepareCommandsStack();
 
  auto process_commands_stack = []() {
    G4MTRunManager* mrm = G4MTRunManager::GetMasterRunManager();
    if (mrm != nullptr) {
      auto cmds = mrm->GetCommandStack();
      for (const auto& itr : cmds)
        G4UImanager::GetUIpointer()->ApplyCommand(itr);  // TLS instance
      mrm->ThisWorkerProcessCommandsStackDone();
    }
  };
 
  if (threadPool != nullptr) threadPool->execute_on_all_threads(process_commands_stack);
}

Referenced by TerminateWorkers().

RunInitialization()

void G4SubEvtRunManager::RunInitialization ( )

overridevirtual

Reimplemented from G4RunManager.

Definition at line 116 of file G4SubEvtRunManager.cc.

{
  G4RunManager::RunInitialization();
  if(!fakeRun) 
  { if(CheckSubEvtTypes()) runInProgress = true; }
}

RunTermination()

void G4SubEvtRunManager::RunTermination ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 457 of file G4SubEvtRunManager.cc.

{
  // Wait for all worker threads to have finished the run
  // i.e. wait for them to return from RunTermination()
  // This guarantee that userrunaction for workers has been called
 
  runInProgress = false;
 
  //TODO (PHASE-II): do we need this???
  workTaskGroup->wait();
 
  // Wait now for all threads to finish event-loop
  WaitForEndEventLoopWorkers();
 
  // Now call base-class method
  G4RunManager::TerminateEventLoop();
  G4RunManager::RunTermination();
 
  if(currentRun!=nullptr) 
  {
    auto eventVector = currentRun->GetEventVector();
    if(eventVector!=nullptr)
    {
      G4int notReady = 1;
      while(notReady>0)
      {
        notReady = 0;
        for(auto ev:*eventVector)
        {
          if(ev->GetNumberOfRemainingSubEvents()>0 || ev->GetNumberOfGrips()>0 )
          { notReady++; }
        }
        if(notReady>0)
        {
          if(verboseLevel>2)
          {
            G4cout << "G4SubEvtRunManager::RunTermination - " << notReady
                   << " events are still incomplete. Waiting for them." << G4endl;
          }
          G4THREADSLEEP(1);
        }
      }
    }
    CleanUpUnnecessaryEvents(0);
  }
}

SetUpAnEvent()

G4bool G4SubEvtRunManager::SetUpAnEvent ( G4Event * , G4long & , G4long & , G4long & , G4bool = true )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 78 of file G4SubEvtRunManager.hh.

    { return false; }

SetUpNEvents()

G4int G4SubEvtRunManager::SetUpNEvents ( G4Event * , G4SeedsQueue * , G4bool = true )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 80 of file G4SubEvtRunManager.hh.

    { return -1; }

SetUpSeedsForSubEvent()

void G4SubEvtRunManager::SetUpSeedsForSubEvent ( G4long & s1, G4long & s2, G4long & s3 )

protected

Definition at line 589 of file G4SubEvtRunManager.cc.

{
  //TODO (PHASE-II): Seeding scheme for sub-event has to be revisited
  G4RNGHelper* helper = G4RNGHelper::GetInstance();
  G4int idx_rndm = nSeedsPerEvent * nSeedsUsed;
  s1 = helper->GetSeed(idx_rndm);
  s2 = helper->GetSeed(idx_rndm + 1);
  if (nSeedsPerEvent == 3) s3 = helper->GetSeed(idx_rndm + 2);
  ++nSeedsUsed;
  if (nSeedsUsed == nSeedsFilled) RefillSeeds();
}

Referenced by GetSubEvent().

SetUserAction() [1/6]

void G4SubEvtRunManager::SetUserAction ( G4UserEventAction * userAction )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 933 of file G4SubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserAction() [2/6]

void G4SubEvtRunManager::SetUserAction ( G4UserRunAction * userAction )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 926 of file G4SubEvtRunManager.cc.

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

SetUserAction() [3/6]

void G4SubEvtRunManager::SetUserAction ( G4UserStackingAction * userAction )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 945 of file G4SubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserAction() [4/6]

void G4SubEvtRunManager::SetUserAction ( G4UserSteppingAction * userAction )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 957 of file G4SubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserAction() [5/6]

void G4SubEvtRunManager::SetUserAction ( G4UserTrackingAction * userAction )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 951 of file G4SubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserAction() [6/6]

void G4SubEvtRunManager::SetUserAction ( G4VUserPrimaryGeneratorAction * userAction )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 939 of file G4SubEvtRunManager.cc.

{
  G4RunManager::SetUserAction(ua);
}

SetUserInitialization() [1/5]

void G4SubEvtRunManager::SetUserInitialization ( G4UserWorkerInitialization * userInit )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 894 of file G4SubEvtRunManager.cc.

{
  userWorkerInitialization = userInit;
}

SetUserInitialization() [2/5]

void G4SubEvtRunManager::SetUserInitialization ( G4UserWorkerThreadInitialization * userInit )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 900 of file G4SubEvtRunManager.cc.

{
  userWorkerThreadInitialization = userInit;
}

SetUserInitialization() [3/5]

void G4SubEvtRunManager::SetUserInitialization ( G4VUserActionInitialization * userInit )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 906 of file G4SubEvtRunManager.cc.

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

SetUserInitialization() [4/5]

void G4SubEvtRunManager::SetUserInitialization ( G4VUserDetectorConstruction * userDC )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 913 of file G4SubEvtRunManager.cc.

{
  G4RunManager::SetUserInitialization(userDC);
}

SetUserInitialization() [5/5]

void G4SubEvtRunManager::SetUserInitialization ( G4VUserPhysicsList * userPL )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 919 of file G4SubEvtRunManager.cc.

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

StackPreviousEvent()

void G4SubEvtRunManager::StackPreviousEvent ( G4Event * anEvent )

overrideprotectedvirtual

Reimplemented from G4RunManager.

Definition at line 154 of file G4SubEvtRunManager.cc.

{
  if(n_perviousEventsToBeStored>0) {
    G4ExceptionDescription ed;
    ed << "G4RunManager::SetNumberOfEventsToBeStored() is not supported in sub-event parallel mode.\n"
       << "User may still keep events bu G4EventManager::KeepTheCurrentEvent()";
    G4Exception("G4SubEvtRunManager::StackPreviousEvent","SubEvtRM1200",FatalException,ed);
    return;
  }
 
  if(anEvent->GetNumberOfRemainingSubEvents()>0)
  // sub-events are still under processing. Event is not yet fully completed.
  {
    currentRun->StoreEvent(anEvent);
  }
  else
  // Event is already completed.
  { 
    // making sure this is the first path
    if(!(anEvent->IsEventCompleted()))
    {
      anEvent->EventCompleted();
      if(userEventAction!=nullptr) userEventAction->EndOfEventAction(anEvent);
      auto pVisManager = G4VVisManager::GetConcreteInstance();
      if (pVisManager) pVisManager->EventReadyForVis(anEvent);
      UpdateScoring(anEvent);
      if(anEvent->ToBeKept() || anEvent->GetNumberOfGrips()>0) 
      { // we keep this event for post-processing (i.e. for vis)
        currentRun->StoreEvent(anEvent);
      }
      else
      { 
        ReportEventDeletion(anEvent);
        delete anEvent;
      }
    } else {
      G4Exception("G4SubEvtRunManager::StackPreviousEvent","SubEvtRM1209",FatalException,"We should not be here!!");
    }
  }
 
  CleanUpUnnecessaryEvents(0);
}

Referenced by TerminateOneEvent().

SubEventFinished()

void G4SubEvtRunManager::SubEventFinished ( const G4SubEvent * se, const G4Event * evt )

overridevirtual

Reimplemented from G4RunManager.

Definition at line 659 of file G4SubEvtRunManager.cc.

{
  G4AutoLock l(&accessSubEventMutex);
  auto masterEvt = se->GetEvent();
  if(masterEvt==nullptr) {
    G4Exception("G4SubEvtRunManager::SubEventFinished()","SERM0001",
      FatalException,"Pointer of master event is null. PANIC!");
    return; // NOLINT: required to help Coverity recognise FatalException as exit point
  }
 
  if(userEventAction) {
    userEventAction->MergeSubEvent(masterEvt,evt);
  }
  if(trajectoriesToBeMerged) MergeTrajectories(se,evt);
  UpdateScoringForSubEvent(se,evt);
  evt->ScoresRecorded();
  eventManager->TerminateSubEvent(se,evt);
}

Referenced by G4WorkerSubEvtRunManager::DoWork().

TerminateOneEvent()

void G4SubEvtRunManager::TerminateOneEvent ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 142 of file G4SubEvtRunManager.cc.

{
  // We must serialize access here because workers may access Run/Event vectors
  // and we can't override StackPreviousEvent
  G4AutoLock l(&accessSubEventMutex);
  StackPreviousEvent(currentEvent);
  currentEvent = nullptr;
  ++numberOfEventProcessed;
}

TerminateWorkers()

void G4SubEvtRunManager::TerminateWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 785 of file G4SubEvtRunManager.cc.

{
  // Force workers to execute (if any) all UI commands left in the stack
  RequestWorkersProcessCommandsStack();
 
  if (workTaskGroup != nullptr) {
    workTaskGroup->join();
    if (!fakeRun)
      threadPool->execute_on_all_threads([]() { G4TaskRunManagerKernel::TerminateWorker(); });
  }
}

ThisWorkerProcessCommandsStackDone()

void G4SubEvtRunManager::ThisWorkerProcessCommandsStackDone ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 852 of file G4SubEvtRunManager.cc.

{}

ThisWorkerWaitForNextAction()

WorkerActionRequest G4SubEvtRunManager::ThisWorkerWaitForNextAction ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 156 of file G4SubEvtRunManager.hh.

    {
      return WorkerActionRequest::UNDEFINED;
    }

TrajectoriesToBeMerged()

void G4SubEvtRunManager::TrajectoriesToBeMerged ( G4bool val = true )

inlineoverridevirtual

Reimplemented from G4RunManager.

Definition at line 210 of file G4SubEvtRunManager.hh.

    { trajectoriesToBeMerged = val; }

UpdateScoringForSubEvent()

void G4SubEvtRunManager::UpdateScoringForSubEvent ( const G4SubEvent * se, const G4Event * evt )

overrideprotectedvirtual

Reimplemented from G4RunManager.

Definition at line 701 of file G4SubEvtRunManager.cc.

{
  auto masterEvt = se->GetEvent();
 
  G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
  if (ScM == nullptr) return;
  auto nPar = (G4int)ScM->GetNumberOfMesh();
  if (nPar < 1) return;
 
  if(verboseLevel>3) {
    G4cout << "merging scores of sub-event belonging to event id #" << masterEvt->GetEventID()
           << " --- sub-event has " << evt->GetHCofThisEvent()->GetCapacity()
           << " hits collections" << G4endl;
  }
  G4HCofThisEvent* HCE = evt->GetHCofThisEvent();
  if (HCE == nullptr) return;
  auto nColl = (G4int)HCE->GetCapacity();
  G4HCofThisEvent* masterHCE = masterEvt->GetHCofThisEvent();
  if (masterHCE == nullptr || (G4int)masterHCE->GetCapacity() != nColl) 
  {
    G4Exception("G4SubEvtRunManager::UpdateScoringForSubEvent()","SERM0002",
      FatalException,"Number of hits colleactions for scrorers mismatch!! PANIC!!");
    return;
  }
  for (G4int i = 0; i < nColl; ++i) {
    auto* HC = dynamic_cast<G4THitsMap<G4double>*>(HCE->GetHC(i));
    auto* masterHC = dynamic_cast<G4THitsMap<G4double>*>(masterHCE->GetHC(i));
    if (HC != nullptr && masterHC != nullptr)
    { *masterHC += *HC; }
    else
    {
       G4Exception("G4SubEvtRunManager::UpdateScoringForSubEvent()","SERM0003",
         FatalException,"HitsCollection is not type of G4THitsMap<G4double>. PANIC!!");
       return;
    }
  }
  
}

Referenced by SubEventFinished().

WaitForEndEventLoopWorkers()

void G4SubEvtRunManager::WaitForEndEventLoopWorkers ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 821 of file G4SubEvtRunManager.cc.

{
  if (workTaskGroup != nullptr) {
    workTaskGroup->join();
    if (!fakeRun)
      threadPool->execute_on_all_threads(
        []() { G4TaskRunManagerKernel::TerminateWorkerRunEventLoop(); });
  }
}

Referenced by RunTermination().

WaitForReadyWorkers()

void G4SubEvtRunManager::WaitForReadyWorkers ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 152 of file G4SubEvtRunManager.hh.

{}

Friends And Related Symbol Documentation

G4RunManagerFactory

friend class G4RunManagerFactory

friend

Definition at line 51 of file G4SubEvtRunManager.hh.

Referenced by G4RunManagerFactory.

Member Data Documentation

runInProgress

std::atomic<G4bool> G4SubEvtRunManager::runInProgress = false

protected

Definition at line 200 of file G4SubEvtRunManager.hh.

Referenced by GetSubEvent(), RunInitialization(), and RunTermination().

---

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

• G4SubEvtRunManager.hh
• G4SubEvtRunManager.cc