#include <G4TaskRunManager.hh>

Inheritance diagram for G4TaskRunManager:

Public Types
using	InitializeSeedsCallback = std::function< G4bool(G4int, G4int &, G4int &)>

using	masterWorlds_t = std::map< G4int, G4VPhysicalVolume * >

typedef TaskRunManager *	pointer

using	ProfilerConfig = G4ProfilerConfig< G4ProfileType::Run >

enum	RMType { sequentialRM , masterRM , workerRM }

using	RunTaskGroup = G4TaskGroup< void >

enum class	WorkerActionRequest { UNDEFINED , NEXTITERATION , PROCESSUI , ENDWORKER }

Public Member Functions
virtual void	AbortEvent () override

virtual void	AbortRun (G4bool softAbort=false) override

virtual void	AnalyzeEvent (G4Event *anEvent)

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

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

void	ConfigureProfilers (G4int argc, char **argv)

virtual G4bool	ConfirmBeamOnCondition ()

virtual void	ConstructScoringWorlds () override

void	CutOffHasBeenModified ()

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

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

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=nullptr) const

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

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

virtual G4Event *	GenerateEvent (G4int i_event)

void	GeometryDirectlyUpdated (G4bool val=true)

void	GeometryHasBeenModified (G4bool prop=true)

std::vector< G4String >	GetCommandStack ()

const G4Event *	GetCurrentEvent () const

const G4Run *	GetCurrentRun () const

G4int	GetEventModulo () const

G4int	GetFlagRandomNumberStatusToG4Event () const

G4bool	GetGeometryToBeOptimized ()

G4int	GetGrainsize () const

const CLHEP::HepRandomEngine *	getMasterRandomEngine () const

G4Run *	GetNonConstCurrentRun () const

G4VUserActionInitialization *	GetNonConstUserActionInitialization () const

virtual size_t	GetNumberActiveThreads () const override

G4int	GetNumberOfEventsPerTask () const

G4int	GetNumberOfEventsToBeProcessed () const

G4int	GetNumberOfParallelWorld () const

G4int	GetNumberOfSelectEvents () const

G4int	GetNumberOfTasks () const

virtual G4int	GetNumberOfThreads () const override

G4int	GetPinAffinity () const

const G4Event *	GetPreviousEvent (G4int i) const

G4int	GetPrintProgress ()

const G4String &	GetRandomNumberStatusForThisEvent () const

const G4String &	GetRandomNumberStatusForThisRun () const

G4bool	GetRandomNumberStore () const

const G4String &	GetRandomNumberStoreDir () const

G4bool	GetRandomNumberStorePerEvent () const

RMType	GetRunManagerType () const

const G4String &	GetSelectMacro () const

TaskManager *	GetTaskManager () const

ThreadPool *	GetThreadPool () const

const G4VUserActionInitialization *	GetUserActionInitialization () const

const G4VUserDetectorConstruction *	GetUserDetectorConstruction () const

const G4UserEventAction *	GetUserEventAction () const

const G4VUserPhysicsList *	GetUserPhysicsList () const

const G4VUserPrimaryGeneratorAction *	GetUserPrimaryGeneratorAction () const

const G4UserRunAction *	GetUserRunAction () const

const G4UserStackingAction *	GetUserStackingAction () const

const G4UserSteppingAction *	GetUserSteppingAction () const

const G4UserTrackingAction *	GetUserTrackingAction () const

const G4UserWorkerInitialization *	GetUserWorkerInitialization () const

const G4UserWorkerThreadInitialization *	GetUserWorkerThreadInitialization () const

int	GetVerbose () const

G4int	GetVerboseLevel () const

const G4String &	GetVersionString () const

virtual void	Initialize () override

virtual void	Initialize (uint64_t nthreads) override

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

virtual void	InitializeGeometry ()

virtual void	InitializePhysics ()

virtual void	InitializeThreadPool () override

bool	IsInitialized () const

void	MergeRun (const G4Run *localRun)

void	MergeScores (const G4ScoringManager *localScoringManager)

void	PhysicsHasBeenModified ()

virtual void	ProcessOneEvent (G4int i_event) override

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

void	ReOptimize (G4LogicalVolume *)

void	ReOptimizeMotherOf (G4VPhysicalVolume *)

virtual void	RequestWorkersProcessCommandsStack () override

virtual void	RestoreRandomNumberStatus (const G4String &fileN)

virtual void	RestoreRndmEachEvent (G4bool)

virtual void	RunInitialization ()

virtual void	RunTermination () override

void	SetDCtable (G4DCtable *DCtbl)

void	SetEventModulo (G4int i=1)

void	SetGeometryToBeOptimized (G4bool vl)

void	SetGrainsize (G4int n)

void	SetInitializeSeedsCallback (InitializeSeedsCallback f)

void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)

void	SetNumberOfEventsToBeProcessed (G4int val)

void	SetNumberOfEventsToBeStored (G4int val)

virtual void	SetNumberOfThreads (G4int n) override

void	SetPinAffinity (G4int n=1)

void	SetPrimaryTransformer (G4PrimaryTransformer *pt)

void	SetPrintProgress (G4int i)

void	SetRandomNumberStore (G4bool flag)

void	SetRandomNumberStoreDir (const G4String &dir)

void	SetRandomNumberStorePerEvent (G4bool flag)

void	SetRunIDCounter (G4int i)

virtual G4bool	SetUpAnEvent (G4Event *, G4long &s1, G4long &s2, G4long &s3, G4bool reseedRequired=true) override

virtual G4int	SetUpNEvents (G4Event , G4SeedsQueue seedsQueue, G4bool reseedRequired=true) override

virtual void	SetUserAction (G4UserEventAction *userAction)

virtual void	SetUserAction (G4UserRunAction *userAction)

virtual void	SetUserAction (G4UserStackingAction *userAction)

virtual void	SetUserAction (G4UserSteppingAction *userAction)

virtual void	SetUserAction (G4UserTrackingAction *userAction)

virtual void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction)

virtual void	SetUserInitialization (G4UserWorkerInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit)

virtual void	SetUserInitialization (G4VUserActionInitialization *userInit)

virtual void	SetUserInitialization (G4VUserDetectorConstruction *userDC)

virtual void	SetUserInitialization (G4VUserPhysicsList *userPL)

void	SetVerbose (int val)

void	SetVerboseLevel (G4int vl)

void	StoreRandomNumberStatusToG4Event (G4int vl)

virtual void	Terminate ()

virtual void	TerminateEventLoop ()

virtual void	TerminateOneEvent () override

virtual void	ThisWorkerEndEventLoop () override

virtual void	ThisWorkerProcessCommandsStackDone () override

virtual void	ThisWorkerReady () override

virtual WorkerActionRequest	ThisWorkerWaitForNextAction () override

G4bool	ThreadPoolIsInitialized () const

virtual void	WaitForEndEventLoopWorkers () override

virtual void	WaitForReadyWorkers () override

virtual	~G4TaskRunManager ()

Static Public Member Functions
static void	addWorld (G4int counter, G4VPhysicalVolume *w)

static TaskRunManager *	GetInstance (bool useTBB=false)

static G4TaskRunManager *	GetMasterRunManager ()

static TaskRunManager *	GetMasterRunManager (bool useTBB=false)

static G4RunManagerKernel *	GetMasterRunManagerKernel ()

static G4ScoringManager *	GetMasterScoringManager ()

static G4ThreadId	GetMasterTheadId ()

static G4ThreadId	GetMasterThreadId ()

static masterWorlds_t &	GetMasterWorlds ()

static G4TaskRunManagerKernel *	GetMTMasterRunManagerKernel ()

static G4RunManager *	GetRunManager ()

static G4bool	IfGeometryHasBeenDestroyed ()

static G4int	SeedOncePerCommunication ()

static void	SetSeedOncePerCommunication (G4int val)

Protected Member Functions
virtual void	AddEventTask (G4int)

void	CleanUpPreviousEvents ()

void	CleanUpUnnecessaryEvents (G4int keepNEvents)

virtual void	ComputeNumberOfTasks ()

virtual void	CreateAndStartWorkers () override

virtual void	DeleteUserInitializations ()

virtual G4bool	InitializeSeeds (G4int) override

virtual void	NewActionRequest (WorkerActionRequest) override

virtual void	PrepareCommandsStack ()

virtual void	RefillSeeds () override

virtual void	rndmSaveThisEvent ()

virtual void	rndmSaveThisRun ()

void	StackPreviousEvent (G4Event *anEvent)

virtual void	StoreRNGStatus (const G4String &filenamePrefix) override

virtual void	TerminateWorkers () override

void	UpdateScoring ()

Protected Attributes
G4MTBarrier	beginOfEventLoopBarrier

G4Event *	currentEvent = nullptr

G4Run *	currentRun = nullptr

G4VPhysicalVolume *	currentWorld = nullptr

G4DCtable *	DCtable = nullptr

G4MTBarrier	endOfEventLoopBarrier

G4EventManager *	eventManager = nullptr

G4int	eventModulo = 1

G4int	eventModuloDef = 0

G4bool	fakeRun = false

G4int	forcedNwokers = -1

G4bool	geometryDirectlyUpdated = false

G4bool	geometryInitialized = false

G4bool	geometryToBeOptimized = true

G4bool	initializedAtLeastOnce = false

InitializeSeedsCallback	initSeedsCallback

G4bool	isScoreNtupleWriter = false

G4RunManagerKernel *	kernel = nullptr

bool	m_is_initialized = false

TaskManager *	m_task_manager = nullptr

VUserTaskQueue *	m_task_queue = nullptr

ThreadPool *	m_thread_pool = nullptr

int	m_verbose = 0

uint64_t	m_workers = 0

G4String	msgText = " "

G4int	n_perviousEventsToBeStored = 0

G4int	n_select_msg = -1

WorkerActionRequest	nextActionRequest = WorkerActionRequest::UNDEFINED

G4MTBarrier	nextActionRequestBarrier

G4int	nParallelWorlds = 0

G4int	nSeedsFilled = 0

G4int	nSeedsMax = 10000

G4int	nSeedsPerEvent = 2

G4int	nSeedsUsed = 0

G4int	numberOfEventProcessed = 0

G4int	numberOfEventToBeProcessed = 0

G4int	nworkers = 2

G4bool	physicsInitialized = false

G4VUserPhysicsList *	physicsList = nullptr

G4bool &	poolInitialized = PTL::TaskRunManager::m_is_initialized

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

G4int	printModulo = -1

G4MTBarrier	processUIBarrier

G4double *	randDbl = nullptr

G4String	randomNumberStatusDir = "./"

G4String	randomNumberStatusForThisEvent = ""

G4String	randomNumberStatusForThisRun = ""

G4bool	rngStatusEventsFlag = false

G4bool	runAborted = false

G4int	runIDCounter = 0

RMType	runManagerType

G4String	selectMacro = ""

G4bool	storeRandomNumberStatus = false

G4int	storeRandomNumberStatusToG4Event = 0

G4TaskManager *&	taskManager = PTL::TaskRunManager::m_task_manager

G4VUserTaskQueue *&	taskQueue = PTL::TaskRunManager::m_task_queue

G4ThreadPool *&	threadPool = PTL::TaskRunManager::m_thread_pool

G4Timer *	timer = nullptr

G4VUserActionInitialization *	userActionInitialization = nullptr

G4VUserDetectorConstruction *	userDetector = nullptr

G4UserEventAction *	userEventAction = nullptr

G4VUserPrimaryGeneratorAction *	userPrimaryGeneratorAction = nullptr

G4UserRunAction *	userRunAction = nullptr

G4UserStackingAction *	userStackingAction = nullptr

G4UserSteppingAction *	userSteppingAction = nullptr

G4UserTrackingAction *	userTrackingAction = nullptr

G4UserWorkerInitialization *	userWorkerInitialization = nullptr

G4UserWorkerThreadInitialization *	userWorkerThreadInitialization = nullptr

G4int	verboseLevel = 0

RunTaskGroup *	workTaskGroup = nullptr

Static Protected Attributes
static G4RUN_DLL G4bool	fGeometryHasBeenDestroyed = false

static G4MTRUN_DLL G4MTRunManager *	fMasterRM = nullptr

static G4MTRUN_DLL G4ScoringManager *	masterScM = nullptr

static G4ThreadId	masterThreadId = G4ThisThread::get_id()

static G4MTRUN_DLL masterWorlds_t	masterWorlds = G4MTRunManager::masterWorlds_t()

static G4int	seedOncePerCommunication = 0

Private Types
using	G4ThreadsList = std::list< G4Thread * >

Static Private Member Functions
static pointer &	GetPrivateMasterRunManager (bool init, bool useTBB=false)

Private Attributes
G4int	eventGrainsize = 0

CLHEP::HepRandomEngine *	masterRNGEngine = nullptr

std::unique_ptr< ProfilerConfig >	masterRunProfiler

G4TaskRunManagerKernel *	MTkernel = nullptr

G4int	numberOfEventsPerTask = -1

G4int	numberOfTasks = -1

G4int	pinAffinity = 0

G4RunMessenger *	runMessenger = nullptr

G4ThreadsList	threads

std::vector< G4String >	uiCmdsForWorkers

bool	workersStarted = false

Static Private Attributes
static G4ThreadLocal G4RunManager *	fRunManager = nullptr

Friends
class	G4RunManagerFactory

Detailed Description

Definition at line 66 of file G4TaskRunManager.hh.

Member Typedef Documentation

◆ G4ThreadsList

using G4MTRunManager::G4ThreadsList = std::list<G4Thread*>

privateinherited

Definition at line 281 of file G4MTRunManager.hh.

◆ InitializeSeedsCallback

using G4TaskRunManager::InitializeSeedsCallback = std::function<G4bool(G4int, G4int&, G4int&)>

Definition at line 77 of file G4TaskRunManager.hh.

◆ masterWorlds_t

using G4MTRunManager::masterWorlds_t = std::map<G4int, G4VPhysicalVolume*>

inherited

Definition at line 68 of file G4MTRunManager.hh.

◆ pointer

typedef TaskRunManager* PTL::TaskRunManager::pointer

inherited

Definition at line 47 of file TaskRunManager.hh.

◆ ProfilerConfig

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

Definition at line 74 of file G4TaskRunManager.hh.

◆ RunTaskGroup

using G4TaskRunManager::RunTaskGroup = G4TaskGroup<void>

Definition at line 78 of file G4TaskRunManager.hh.

Member Enumeration Documentation

◆ RMType

enum G4RunManager::RMType

inherited

Enumerator
sequentialRM
masterRM
workerRM

Definition at line 575 of file G4RunManager.hh.

    {
      sequentialRM,
      masterRM,
      workerRM
    };

◆ WorkerActionRequest

enum class G4MTRunManager::WorkerActionRequest

stronginherited

Enumerator
UNDEFINED
NEXTITERATION
PROCESSUI
ENDWORKER

Definition at line 167 of file G4MTRunManager.hh.

    {
      UNDEFINED,
      NEXTITERATION,  // There is another set of UI commands to be executed
      PROCESSUI,      // Process UI commands w/o a /run/beamOn
      ENDWORKER       // Terminate thread, work finished
    };

Constructor & Destructor Documentation

◆ G4TaskRunManager() [1/2]

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

Definition at line 162 of file G4TaskRunManager.cc.

163 : G4TaskRunManager(nullptr, useTBB, 0)

164{}

G4TaskRunManager::G4TaskRunManager

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

Definition: G4TaskRunManager.cc:162

◆ G4TaskRunManager() [2/2]

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

Definition at line 77 of file G4TaskRunManager.cc.

  : G4MTRunManager()
  , PTL::TaskRunManager(useTBB)
  , eventGrainsize(grainsize)
  , numberOfEventsPerTask(-1)
  , numberOfTasks(-1)
  , masterRNGEngine(nullptr)
  , workTaskGroup(nullptr)
{
  if(task_queue)
    taskQueue = task_queue;
 
  // override default of 2 from G4MTRunManager
  nworkers  = G4Threading::G4GetNumberOfCores();
  fMasterRM = this;
  MTkernel  = static_cast<G4TaskRunManagerKernel*>(kernel);
 
  G4int numberOfStaticAllocators = kernel->GetNumberOfStaticAllocators();
  if(numberOfStaticAllocators > 0)
  {
    G4ExceptionDescription msg1;
    msg1 << "There are " << numberOfStaticAllocators
         << " static G4Allocator objects detected.\n"
         << "In multi-threaded mode, all G4Allocator objects must "
         << "be dynamicly instantiated.";
    G4Exception("G4TaskRunManager::G4TaskRunManager", "Run1035", FatalException,
                msg1);
  }
 
  G4UImanager::GetUIpointer()->SetMasterUIManager(true);
  masterScM = G4ScoringManager::GetScoringManagerIfExist();
 
  // use default RandomNumberGenerator if created by user, or create default
  masterRNGEngine = G4Random::getTheEngine();
 
  numberOfEventToBeProcessed = 0;
  randDbl                    = new G4double[nSeedsPerEvent * nSeedsMax];
 
  //------------------------------------------------------------------------//
  //      handle threading
  //------------------------------------------------------------------------//
  G4String _nthread_env = G4GetEnv<G4String>("G4FORCENUMBEROFTHREADS", "");
  for(auto& itr : _nthread_env)
    itr = tolower(itr);
 
  if(_nthread_env == "max")
    forcedNwokers = G4Threading::G4GetNumberOfCores();
  else if(!_nthread_env.empty())
  {
    std::stringstream ss;
    G4int _nthread_val = -1;
    ss << _nthread_env;
    ss >> _nthread_val;
    if(_nthread_val > 0)
      forcedNwokers = _nthread_val;
 
    if(forcedNwokers > 0)
      nworkers = forcedNwokers;
  }
 
  //------------------------------------------------------------------------//
  //      option for forcing TBB
  //------------------------------------------------------------------------//
#ifdef GEANT4_USE_TBB
  G4int _useTBB = G4GetEnv<G4int>("G4FORCE_TBB", (G4int) useTBB);
  if(_useTBB > 0)
    useTBB = true;
#else
  if(useTBB)
  {
    G4ExceptionDescription msg;
    msg << "TBB was requested but Geant4 was not built with TBB support";
    G4Exception("G4TaskRunManager::G4TaskRunManager(...)", "Run0131",
                JustWarning, msg);
  }
  useTBB = false;
#endif
 
  // handle TBB
  G4ThreadPool::set_use_tbb(useTBB);
}

References FatalException, G4MTRunManager::fMasterRM, G4MTRunManager::forcedNwokers, G4Exception(), G4Threading::G4GetNumberOfCores(), G4RunManagerKernel::GetNumberOfStaticAllocators(), G4ScoringManager::GetScoringManagerIfExist(), G4UImanager::GetUIpointer(), JustWarning, G4RunManager::kernel, masterRNGEngine, G4MTRunManager::masterScM, MTkernel, G4MTRunManager::nSeedsMax, G4MTRunManager::nSeedsPerEvent, G4MTRunManager::numberOfEventToBeProcessed, G4MTRunManager::nworkers, G4MTRunManager::randDbl, PTL::ThreadPool::set_use_tbb(), G4UImanager::SetMasterUIManager(), and taskQueue.

◆ ~G4TaskRunManager()

G4TaskRunManager::~G4TaskRunManager ( )

virtual

Definition at line 168 of file G4TaskRunManager.cc.

{
  // finalize profiler before shutting down the threads
  G4Profiler::Finalize();
 
  // terminate all the workers
  G4TaskRunManager::TerminateWorkers();
 
  // trigger all G4AutoDelete instances
  G4ThreadLocalSingleton<void>::Clear();
 
  // delete the task-group
  delete workTaskGroup;
  workTaskGroup = nullptr;
 
  // destroy the thread-pool
  if(threadPool)
    threadPool->destroy_threadpool();
 
  PTL::TaskRunManager::Terminate();
}

References G4ThreadLocalSingleton< T >::Clear(), PTL::ThreadPool::destroy_threadpool(), G4Profiler::Finalize(), PTL::TaskRunManager::Terminate(), TerminateWorkers(), threadPool, and workTaskGroup.

Member Function Documentation

◆ AbortEvent()

void G4TaskRunManager::AbortEvent ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 752 of file G4TaskRunManager.cc.

{
  // nothing to do in the master thread
}

◆ AbortRun()

void G4TaskRunManager::AbortRun ( G4bool softAbort = false )

overridevirtual

Reimplemented from G4MTRunManager.

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

References G4TaskRunManagerKernel::BroadcastAbortRun(), G4cerr, G4endl, G4State_EventProc, G4State_GeomClosed, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), MTkernel, and G4RunManager::runAborted.

◆ AddEventTask()

void G4TaskRunManager::AddEventTask ( G4int nt )

protectedvirtual

Definition at line 471 of file G4TaskRunManager.cc.

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

References PTL::TaskGroup< Tp, Arg, MaxDepth >::exec(), G4TaskRunManagerKernel::ExecuteWorkerTask(), G4cout, G4endl, G4RunManager::verboseLevel, and workTaskGroup.

Referenced by CreateAndStartWorkers().

◆ addWorld()

void G4MTRunManager::addWorld	(	G4int	counter,
		G4VPhysicalVolume *	w
	)

staticinherited

Definition at line 96 of file G4MTRunManager.cc.

{
  masterWorlds.insert(std::make_pair(counter, w));
}

References G4MTRunManager::masterWorlds.

Referenced by G4MTRunManager::ConstructScoringWorlds(), and ConstructScoringWorlds().

◆ AnalyzeEvent()

void G4RunManager::AnalyzeEvent ( G4Event * anEvent )

virtualinherited

Definition at line 548 of file G4RunManager.cc.

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

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

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

◆ BeamOn()

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

virtualinherited

Definition at line 273 of file G4RunManager.cc.

{
  if(n_event <= 0)
  {
    fakeRun = true;
  }
  else
  {
    fakeRun = false;
  }
  G4bool cond = ConfirmBeamOnCondition();
  if(cond)
  {
    numberOfEventToBeProcessed = n_event;
    numberOfEventProcessed     = 0;
    ConstructScoringWorlds();
    RunInitialization();
    DoEventLoop(n_event, macroFile, n_select);
    RunTermination();
  }
  fakeRun = false;
}

References G4RunManager::ConfirmBeamOnCondition(), G4RunManager::ConstructScoringWorlds(), G4RunManager::DoEventLoop(), G4RunManager::fakeRun, G4RunManager::numberOfEventProcessed, G4RunManager::numberOfEventToBeProcessed, G4RunManager::RunInitialization(), and G4RunManager::RunTermination().

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

◆ CleanUpPreviousEvents()

void G4RunManager::CleanUpPreviousEvents ( )

protectedinherited

Definition at line 589 of file G4RunManager.cc.

{
  // Delete all events carried over from previous run.
  // This method is invoked at the beginning of the next run
  // or from the destructor of G4RunManager at the very end of
  // the program.
  // N.B. If ToBeKept() is true, the pointer of this event is
  // kept in G4Run of the previous run, and deleted along with
  // the deletion of G4Run.
 
  auto evItr = previousEvents->cbegin();
  while(evItr != previousEvents->cend())
  {
    G4Event* evt = *evItr;
    if(evt != nullptr && !(evt->ToBeKept()))
      delete evt;
    evItr = previousEvents->erase(evItr);
  }
}

References G4RunManager::previousEvents, and G4Event::ToBeKept().

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

◆ CleanUpUnnecessaryEvents()

void G4RunManager::CleanUpUnnecessaryEvents ( G4int keepNEvents )

protectedinherited

Definition at line 610 of file G4RunManager.cc.

{
  // Delete events that are no longer necessary for post
  // processing such as visualization.
  // N.B. If ToBeKept() is true, the pointer of this event is
  // kept in G4Run of the previous run, and deleted along with
  // the deletion of G4Run.
 
  auto evItr = previousEvents->cbegin();
  while(evItr != previousEvents->cend())
  {
    if(G4int(previousEvents->size()) <= keepNEvents)
      return;
 
    G4Event* evt = *evItr;
    if(evt != nullptr)
    {
      if(evt->GetNumberOfGrips() == 0)
      {
        if(!(evt->ToBeKept()))
          delete evt;
        evItr = previousEvents->erase(evItr);
      }
      else
      {
        ++evItr;
      }
    }
    else
    {
      evItr = previousEvents->erase(evItr);
    }
  }
}

References G4Event::GetNumberOfGrips(), G4RunManager::previousEvents, and G4Event::ToBeKept().

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

◆ ComputeNumberOfTasks()

void G4TaskRunManager::ComputeNumberOfTasks ( )

protectedvirtual

Definition at line 311 of file G4TaskRunManager.cc.

{
  G4int grainSize = (eventGrainsize == 0) ? threadPool->size() : eventGrainsize;
  grainSize =
    G4GetEnv<G4int>("G4FORCE_GRAINSIZE", grainSize, "Forcing grainsize...");
  if(grainSize == 0)
    grainSize = 1;
 
  G4int nEvtsPerTask = (numberOfEventToBeProcessed > grainSize)
                         ? (numberOfEventToBeProcessed / grainSize)
                         : 1;
 
  if(eventModuloDef > 0)
  {
    eventModulo = eventModuloDef;
  }
  else
  {
    eventModulo = G4int(std::sqrt(G4double(numberOfEventToBeProcessed)));
    if(eventModulo < 1)
      eventModulo = 1;
  }
  if(eventModulo > nEvtsPerTask)
  {
    G4int oldMod = eventModulo;
    eventModulo  = nEvtsPerTask;
 
    G4ExceptionDescription msgd;
    msgd << "Event modulo is reduced to " << eventModulo << " (was " << oldMod
         << ")"
         << " to distribute events to all threads.";
    G4Exception("G4TaskRunManager::InitializeEventLoop()", "Run10035",
                JustWarning, msgd);
  }
  nEvtsPerTask = eventModulo;
 
  if(fakeRun)
    nEvtsPerTask = G4GetEnv<G4int>(
      "G4FORCE_EVENTS_PER_TASK", nEvtsPerTask,
      "Forcing number of events per task (overrides grainsize)...");
  else
    nEvtsPerTask = G4GetEnv<G4int>("G4FORCE_EVENTS_PER_TASK", nEvtsPerTask);
 
  if(nEvtsPerTask < 1)
    nEvtsPerTask = 1;
 
  numberOfTasks         = numberOfEventToBeProcessed / nEvtsPerTask;
  numberOfEventsPerTask = nEvtsPerTask;
  eventModulo           = numberOfEventsPerTask;
 
  if(fakeRun && verboseLevel > 1)
  {
    std::stringstream msg;
    msg << "--> G4TaskRunManager::ComputeNumberOfTasks() --> " << numberOfTasks
        << " tasks with " << numberOfEventsPerTask << " events/task...";
 
    std::stringstream ss;
    ss.fill('=');
    ss << std::setw(msg.str().length()) << "";
    G4cout << "\n"
           << ss.str() << "\n"
           << msg.str() << "\n"
           << ss.str() << "\n"
           << G4endl;
  }
}

References eventGrainsize, G4MTRunManager::eventModulo, G4MTRunManager::eventModuloDef, G4RunManager::fakeRun, G4cout, G4endl, G4Exception(), JustWarning, numberOfEventsPerTask, G4MTRunManager::numberOfEventToBeProcessed, numberOfTasks, PTL::ThreadPool::size(), threadPool, and G4RunManager::verboseLevel.

Referenced by CreateAndStartWorkers(), and InitializeEventLoop().

◆ ConfigureProfilers() [1/2]

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

virtualinherited

Definition at line 1198 of file G4RunManager.cc.

{
#ifdef GEANT4_USE_TIMEMORY
  // parse command line if arguments were passed
  G4Profiler::Configure(args);
#else
  G4ConsumeParameters(args);
#endif
}

References args, G4Profiler::Configure(), and G4ConsumeParameters().

Referenced by G4RunManager::ConfigureProfilers(), and G4RunManager::G4RunManager().

◆ ConfigureProfilers() [2/2]

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

inherited

Definition at line 1189 of file G4RunManager.cc.

{
  std::vector<std::string> _args;
  for(G4int i = 0; i < argc; ++i)
    _args.push_back(argv[i]);
  ConfigureProfilers(_args);
}

References G4RunManager::ConfigureProfilers().

◆ ConfirmBeamOnCondition()

G4bool G4RunManager::ConfirmBeamOnCondition ( )

virtualinherited

Definition at line 297 of file G4RunManager.cc.

{
  G4StateManager* stateManager = G4StateManager::GetStateManager();
 
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_PreInit && currentState != G4State_Idle)
  {
    G4cerr << "Illegal application state - BeamOn() ignored." << G4endl;
    return false;
  }
 
  if(!initializedAtLeastOnce)
  {
    G4cerr << " Geant4 kernel should be initialized" << G4endl;
    G4cerr << "before the first BeamOn(). - BeamOn ignored." << G4endl;
    return false;
  }
 
  if(!geometryInitialized || !physicsInitialized)
  {
    if(verboseLevel > 0)
    {
      G4cout << "Start re-initialization because " << G4endl;
      if(!geometryInitialized)
        G4cout << "  Geometry" << G4endl;
      if(!physicsInitialized)
        G4cout << "  Physics processes" << G4endl;
      G4cout << "has been modified since last Run." << G4endl;
    }
    Initialize();
  }
  return true;
}

References G4cerr, G4cout, G4endl, G4State_Idle, G4State_PreInit, G4RunManager::geometryInitialized, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4RunManager::Initialize(), G4RunManager::initializedAtLeastOnce, G4RunManager::physicsInitialized, and G4RunManager::verboseLevel.

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

◆ ConstructScoringWorlds()

void G4TaskRunManager::ConstructScoringWorlds ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 613 of file G4TaskRunManager.cc.

{
  masterScM = G4ScoringManager::GetScoringManagerIfExist();
  // Call base class stuff...
  G4RunManager::ConstructScoringWorlds();
 
  masterWorlds.clear();
  size_t nWorlds =
    G4TransportationManager::GetTransportationManager()->GetNoWorlds();
  std::vector<G4VPhysicalVolume*>::iterator itrW =
    G4TransportationManager::GetTransportationManager()->GetWorldsIterator();
  for(size_t iWorld = 0; iWorld < nWorlds; ++iWorld)
  {
    addWorld(iWorld, *itrW);
    ++itrW;
  }
}

References G4MTRunManager::addWorld(), G4RunManager::ConstructScoringWorlds(), G4TransportationManager::GetNoWorlds(), G4ScoringManager::GetScoringManagerIfExist(), G4TransportationManager::GetTransportationManager(), G4TransportationManager::GetWorldsIterator(), G4MTRunManager::masterScM, and G4MTRunManager::masterWorlds.

◆ CreateAndStartWorkers()

void G4TaskRunManager::CreateAndStartWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 380 of file G4TaskRunManager.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 bool initializeStarted = false;
 
  ComputeNumberOfTasks();
 
  if(fakeRun)
  {
    if(initializeStarted)
    {
      auto initCmdStack = GetCommandStack();
      if(!initCmdStack.empty())
      {
        threadPool->execute_on_all_threads([initCmdStack]() {
          for(auto& itr : initCmdStack)
            G4UImanager::GetUIpointer()->ApplyCommand(itr);
          G4WorkerTaskRunManager::GetWorkerRunManager()->DoWork();
        });
      }
    }
    else
    {
      std::stringstream msg;
      msg << "--> G4TaskRunManager::CreateAndStartWorkers() --> "
          << "Initializing workers...";
 
      std::stringstream ss;
      ss.fill('=');
      ss << std::setw(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([initCmdStack]() {
        for(auto& itr : initCmdStack)
          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(); });
 
    {
      std::stringstream msg;
      msg << "--> G4TaskRunManager::CreateAndStartWorkers() --> "
          << "Creating " << numberOfTasks << " tasks with "
          << numberOfEventsPerTask << " events/task...";
 
      std::stringstream ss;
      ss.fill('=');
      ss << std::setw(msg.str().length()) << "";
      G4cout << "\n"
             << ss.str() << "\n"
             << msg.str() << "\n"
             << ss.str() << "\n"
             << G4endl;
    }
 
    G4int remaining = numberOfEventToBeProcessed;
    for(G4int nt = 0; nt < numberOfTasks + 1; ++nt)
    {
      if(remaining > 0)
        AddEventTask(nt);
      remaining -= numberOfEventsPerTask;
    }
    workTaskGroup->wait();
  }
}

References AddEventTask(), ComputeNumberOfTasks(), G4WorkerTaskRunManager::DoWork(), PTL::ThreadPool::execute_on_all_threads(), G4TaskRunManagerKernel::ExecuteWorkerInit(), G4RunManager::fakeRun, G4cout, G4endl, G4MTRunManager::GetCommandStack(), G4UImanager::GetUIpointer(), G4WorkerTaskRunManager::GetWorkerRunManager(), G4TaskRunManagerKernel::InitCommandStack(), G4TaskRunManagerKernel::InitializeWorker(), numberOfEventsPerTask, G4MTRunManager::numberOfEventToBeProcessed, numberOfTasks, threadPool, PTL::TaskGroup< Tp, Arg, MaxDepth >::wait(), and workTaskGroup.

Referenced by InitializeEventLoop().

◆ CutOffHasBeenModified()

void G4RunManager::CutOffHasBeenModified ( )

inlineinherited

Definition at line 301 of file G4RunManager.hh.

    {
      G4cerr << "CutOffHasBeenModified becomes obsolete." << G4endl;
      G4cerr << "It is safe to remove invoking this method." << G4endl;
    }

References G4cerr, and G4endl.

◆ DefineWorldVolume()

void G4RunManager::DefineWorldVolume	(	G4VPhysicalVolume *	worldVol,
		G4bool	topologyIsChanged = `true`
	)

virtualinherited

Definition at line 791 of file G4RunManager.cc.

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

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

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

◆ DeleteUserInitializations()

void G4RunManager::DeleteUserInitializations ( )

protectedvirtualinherited

Definition at line 244 of file G4RunManager.cc.

{
  delete userDetector;
  userDetector = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserDetectorConstruction deleted." << G4endl;
 
  delete physicsList;
  physicsList = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserPhysicsList deleted." << G4endl;
 
  delete userActionInitialization;
  userActionInitialization = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserActionInitialization deleted." << G4endl;
 
  delete userWorkerInitialization;
  userWorkerInitialization = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserWorkerInitialization deleted." << G4endl;
 
  delete userWorkerThreadInitialization;
  userWorkerThreadInitialization = nullptr;
  if(verboseLevel > 1)
    G4cout << "UserWorkerThreadInitialization deleted." << G4endl;
}

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

Referenced by G4RunManager::~G4RunManager().

◆ DoEventLoop()

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

virtualinherited

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 412 of file G4RunManager.cc.

{
  InitializeEventLoop(n_event, macroFile, n_select);
 
  // Event loop
  for(G4int i_event = 0; i_event < n_event; ++i_event)
  {
    ProcessOneEvent(i_event);
    TerminateOneEvent();
    if(runAborted)
      break;
  }
 
  // For G4MTRunManager, TerminateEventLoop() is invoked after all threads are
  // finished.
  if(runManagerType == sequentialRM)
    TerminateEventLoop();
}

References G4RunManager::InitializeEventLoop(), G4RunManager::ProcessOneEvent(), G4RunManager::runAborted, G4RunManager::runManagerType, G4RunManager::sequentialRM, G4RunManager::TerminateEventLoop(), and G4RunManager::TerminateOneEvent().

Referenced by G4RunManager::BeamOn().

◆ DumpRegion() [1/2]

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

inherited

Definition at line 890 of file G4RunManager.cc.

{
  kernel->DumpRegion(rname);
}

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

Referenced by G4RunMessenger::SetNewValue().

◆ DumpRegion() [2/2]

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

inherited

Definition at line 896 of file G4RunManager.cc.

{
  kernel->DumpRegion(region);
}

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

◆ GenerateEvent()

G4Event * G4RunManager::GenerateEvent ( G4int i_event )

virtualinherited

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 500 of file G4RunManager.cc.

{
  if(userPrimaryGeneratorAction == nullptr)
  {
    G4Exception("G4RunManager::GenerateEvent()", "Run0032", FatalException,
                "G4VUserPrimaryGeneratorAction is not defined!");
    return nullptr;
  }
 
  G4Event* anEvent = new G4Event(i_event);
 
  if(storeRandomNumberStatusToG4Event == 1 ||
     storeRandomNumberStatusToG4Event == 3)
  {
    std::ostringstream oss;
    G4Random::saveFullState(oss);
    randomNumberStatusForThisEvent = oss.str();
    anEvent->SetRandomNumberStatus(randomNumberStatusForThisEvent);
  }
 
  if(storeRandomNumberStatus)
  {
    G4String fileN = "currentEvent";
    if(rngStatusEventsFlag)
    {
      std::ostringstream os;
      os << "run" << currentRun->GetRunID() << "evt" << anEvent->GetEventID();
      fileN = os.str();
    }
    StoreRNGStatus(fileN);
  }
 
  if(printModulo > 0 && anEvent->GetEventID() % printModulo == 0)
  {
    G4cout << "--> Event " << anEvent->GetEventID() << " starts." << G4endl;
  }
  userPrimaryGeneratorAction->GeneratePrimaries(anEvent);
  return anEvent;
}

References G4RunManager::currentRun, FatalException, G4cout, G4endl, G4Exception(), G4VUserPrimaryGeneratorAction::GeneratePrimaries(), G4Event::GetEventID(), G4Run::GetRunID(), G4RunManager::printModulo, G4RunManager::randomNumberStatusForThisEvent, G4RunManager::rngStatusEventsFlag, G4Event::SetRandomNumberStatus(), G4RunManager::storeRandomNumberStatus, G4RunManager::storeRandomNumberStatusToG4Event, G4RunManager::StoreRNGStatus(), and G4RunManager::userPrimaryGeneratorAction.

Referenced by G4RunManager::ProcessOneEvent().

◆ GeometryDirectlyUpdated()

void G4RunManager::GeometryDirectlyUpdated ( G4bool val = true )

inlineinherited

Definition at line 331 of file G4RunManager.hh.

    {
      geometryDirectlyUpdated = val;
    }

References G4RunManager::geometryDirectlyUpdated.

Referenced by G4GDMLMessenger::SetNewValue().

◆ GeometryHasBeenModified()

void G4RunManager::GeometryHasBeenModified ( G4bool prop = true )

inherited

Definition at line 1117 of file G4RunManager.cc.

{
  if(prop)
  {
    G4UImanager::GetUIpointer()->ApplyCommand("/run/geometryModified");
  }
  else
  {
    kernel->GeometryHasBeenModified();
  }
}

References G4UImanager::ApplyCommand(), G4RunManagerKernel::GeometryHasBeenModified(), G4UImanager::GetUIpointer(), and G4RunManager::kernel.

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

◆ GetCommandStack()

std::vector< G4String > G4MTRunManager::GetCommandStack ( )

inherited

Definition at line 323 of file G4MTRunManager.cc.

{
  G4AutoLock l(&cmdHandlingMutex);
  return uiCmdsForWorkers;
}

References anonymous_namespace{G4MTRunManager.cc}::cmdHandlingMutex, and G4MTRunManager::uiCmdsForWorkers.

Referenced by CreateAndStartWorkers(), G4WorkerRunManager::DoWork(), G4WorkerTaskRunManager::ProcessUI(), and RequestWorkersProcessCommandsStack().

◆ GetCurrentEvent()

const G4Event * G4RunManager::GetCurrentEvent ( ) const

inlineinherited

Definition at line 537 of file G4RunManager.hh.

537{ return currentEvent; }

G4RunManager::currentEvent

G4Event * currentEvent

Definition: G4RunManager.hh:631

References G4RunManager::currentEvent.

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

◆ GetCurrentRun()

const G4Run * G4RunManager::GetCurrentRun ( ) const

inlineinherited

Definition at line 533 of file G4RunManager.hh.

533{ return currentRun; }

References G4RunManager::currentRun.

Referenced by G4TheMTRayTracer::CreateBitMap(), G4TrajectoriesModel::DescribeYourselfTo(), G4WorkerTaskRunManager::DoWork(), G4VisManager::Draw(), G4VisManager::Enable(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), export_G4RunManager(), G4VisCommandSceneAddEventID::EventID::operator()(), G4VSceneHandler::ProcessScene(), G4OpenGLSceneHandler::ScaledFlush(), G4VisCommandReviewKeptEvents::SetNewValue(), and G4VisCommandSceneEndOfEventAction::SetNewValue().

◆ GetEventModulo()

G4int G4MTRunManager::GetEventModulo ( ) const

inlineinherited

Definition at line 188 of file G4MTRunManager.hh.

188{ return eventModuloDef; }

References G4MTRunManager::eventModuloDef.

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

◆ GetFlagRandomNumberStatusToG4Event()

G4int G4RunManager::GetFlagRandomNumberStatusToG4Event ( ) const

inlineinherited

Definition at line 451 of file G4RunManager.hh.

    {
      return storeRandomNumberStatusToG4Event;
    }

References G4RunManager::storeRandomNumberStatusToG4Event.

Referenced by G4RunMessenger::GetCurrentValue().

◆ GetGeometryToBeOptimized()

G4bool G4RunManager::GetGeometryToBeOptimized ( )

inlineinherited

Definition at line 326 of file G4RunManager.hh.

    {
      return geometryToBeOptimized;
    }

References G4RunManager::geometryToBeOptimized.

Referenced by export_G4RunManager().

◆ GetGrainsize()

G4int G4TaskRunManager::GetGrainsize ( ) const

inline

Definition at line 93 of file G4TaskRunManager.hh.

93{ return eventGrainsize; }

References eventGrainsize.

◆ GetInstance()

TaskRunManager * TaskRunManager::GetInstance ( bool useTBB = false )

staticinherited

Definition at line 58 of file TaskRunManager.cc.

{
    return GetMasterRunManager(useTBB);
}

References PTL::TaskRunManager::GetMasterRunManager().

◆ getMasterRandomEngine()

const CLHEP::HepRandomEngine * G4MTRunManager::getMasterRandomEngine ( ) const

inlineinherited

Definition at line 137 of file G4MTRunManager.hh.

    {
      return masterRNGEngine;
    }

References G4MTRunManager::masterRNGEngine.

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

◆ GetMasterRunManager() [1/2]

static G4TaskRunManager * G4TaskRunManager::GetMasterRunManager ( )

inlinestatic

Definition at line 166 of file G4TaskRunManager.hh.

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

References G4MTRunManager::GetMasterRunManager().

Referenced by G4WorkerTaskRunManager::DoWork(), G4TaskRunManagerKernel::ExecuteWorkerInit(), G4TaskRunManagerKernel::ExecuteWorkerTask(), G4RunManagerFactory::GetMTMasterRunManager(), GetMTMasterRunManagerKernel(), G4TaskRunManagerKernel::InitializeWorker(), G4WorkerTaskRunManager::ProcessUI(), G4WorkerTaskRunManager::RunInitialization(), and G4TaskRunManagerKernel::TerminateWorker().

◆ GetMasterRunManager() [2/2]

TaskRunManager * TaskRunManager::GetMasterRunManager ( bool useTBB = false )

staticinherited

Definition at line 49 of file TaskRunManager.cc.

{
    static pointer& _instance = GetPrivateMasterRunManager(true, useTBB);
    return _instance;
}

References PTL::TaskRunManager::GetPrivateMasterRunManager().

Referenced by PTL::internal::get_default_threadpool(), PTL::TaskManager::GetInstance(), PTL::TaskRunManager::GetInstance(), and PTL::VUserTaskQueue::VUserTaskQueue().

◆ GetMasterRunManagerKernel()

G4RunManagerKernel * G4MTRunManager::GetMasterRunManagerKernel ( )

staticinherited

Definition at line 72 of file G4MTRunManager.cc.

{
  return fMasterRM->kernel;
}

References G4MTRunManager::fMasterRM, and G4RunManager::kernel.

Referenced by G4WorkerRunManager::InitializeGeometry().

◆ GetMasterScoringManager()

G4ScoringManager * G4MTRunManager::GetMasterScoringManager ( )

staticinherited

Definition at line 84 of file G4MTRunManager.cc.

{
  return masterScM;
}

References G4MTRunManager::masterScM.

Referenced by G4WorkerRunManager::ConstructScoringWorlds(), and G4WorkerRunManager::G4WorkerRunManager().

◆ GetMasterTheadId()

static G4ThreadId G4MTRunManager::GetMasterTheadId ( )

staticinherited

◆ GetMasterThreadId()

G4ThreadId G4TaskRunManager::GetMasterThreadId ( )

static

Definition at line 192 of file G4TaskRunManager.cc.

{
  return G4MTRunManager::GetMasterThreadId();
}

References G4MTRunManager::GetMasterThreadId().

◆ GetMasterWorlds()

G4MTRunManager::masterWorlds_t & G4MTRunManager::GetMasterWorlds ( )

staticinherited

Definition at line 90 of file G4MTRunManager.cc.

{
  return masterWorlds;
}

References G4MTRunManager::masterWorlds.

Referenced by G4RunManagerKernel::WorkerDefineWorldVolume(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

◆ GetMTMasterRunManagerKernel()

G4TaskRunManagerKernel * G4TaskRunManager::GetMTMasterRunManagerKernel ( )

static

Definition at line 70 of file G4TaskRunManager.cc.

{
  return GetMasterRunManager()->MTkernel;
}

References GetMasterRunManager(), and MTkernel.

◆ GetNonConstCurrentRun()

G4Run * G4RunManager::GetNonConstCurrentRun ( ) const

inlineinherited

Definition at line 534 of file G4RunManager.hh.

534{ return currentRun; }

References G4RunManager::currentRun.

◆ GetNonConstUserActionInitialization()

G4VUserActionInitialization * G4RunManager::GetNonConstUserActionInitialization ( ) const

inlineinherited

Definition at line 384 of file G4RunManager.hh.

    {
      return userActionInitialization;
    }

References G4RunManager::userActionInitialization.

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

◆ GetNumberActiveThreads()

virtual size_t G4TaskRunManager::GetNumberActiveThreads ( ) const

inlineoverridevirtual

Reimplemented from PTL::TaskRunManager.

Definition at line 105 of file G4TaskRunManager.hh.

  {
    return PTL::TaskRunManager::GetNumberActiveThreads();
  }

References PTL::TaskRunManager::GetNumberActiveThreads().

◆ GetNumberOfEventsPerTask()

G4int G4TaskRunManager::GetNumberOfEventsPerTask ( ) const

inline

Definition at line 95 of file G4TaskRunManager.hh.

  {
    return numberOfEventsPerTask;
  }

References numberOfEventsPerTask.

◆ GetNumberOfEventsToBeProcessed()

G4int G4RunManager::GetNumberOfEventsToBeProcessed ( ) const

inlineinherited

Definition at line 567 of file G4RunManager.hh.

    {
      return numberOfEventToBeProcessed;
    }

References G4RunManager::numberOfEventToBeProcessed.

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

◆ GetNumberOfParallelWorld()

G4int G4RunManager::GetNumberOfParallelWorld ( ) const

inlineinherited

Definition at line 562 of file G4RunManager.hh.

562{ return nParallelWorlds; }

G4RunManager::nParallelWorlds

G4int nParallelWorlds

Definition: G4RunManager.hh:645

References G4RunManager::nParallelWorlds.

◆ GetNumberOfSelectEvents()

G4int G4RunManager::GetNumberOfSelectEvents ( ) const

inlineinherited

Definition at line 571 of file G4RunManager.hh.

571{ return n_select_msg; }

G4RunManager::n_select_msg

G4int n_select_msg

Definition: G4RunManager.hh:648

References G4RunManager::n_select_msg.

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

◆ GetNumberOfTasks()

G4int G4TaskRunManager::GetNumberOfTasks ( ) const

inline

Definition at line 94 of file G4TaskRunManager.hh.

94{ return numberOfTasks; }

References numberOfTasks.

◆ GetNumberOfThreads()

virtual G4int G4TaskRunManager::GetNumberOfThreads ( ) const

inlineoverridevirtual

Reimplemented from PTL::TaskRunManager.

Definition at line 101 of file G4TaskRunManager.hh.

  {
    return PTL::TaskRunManager::GetNumberOfThreads();
  }

References PTL::TaskRunManager::GetNumberOfThreads().

◆ GetPinAffinity()

G4int G4MTRunManager::GetPinAffinity ( ) const

inlineinherited

Definition at line 77 of file G4MTRunManager.hh.

77{ return pinAffinity; }

G4MTRunManager::pinAffinity

G4int pinAffinity

Definition: G4MTRunManager.hh:284

References G4MTRunManager::pinAffinity.

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

◆ GetPreviousEvent()

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

inlineinherited

Definition at line 540 of file G4RunManager.hh.

    {
      if(i >= 1 && i <= n_perviousEventsToBeStored)
      {
        auto itr = previousEvents->cbegin();
        for(G4int j = 1; j < i; ++j)
        {
          ++itr;
        }
        return *itr;
      }
      return nullptr;
    }

References G4RunManager::n_perviousEventsToBeStored, and G4RunManager::previousEvents.

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

◆ GetPrintProgress()

G4int G4RunManager::GetPrintProgress ( )

inlineinherited

Definition at line 521 of file G4RunManager.hh.

521{ return printModulo; }

References G4RunManager::printModulo.

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

◆ GetPrivateMasterRunManager()

TaskRunManager::pointer & TaskRunManager::GetPrivateMasterRunManager	(	bool	init,
		bool	useTBB = `false`
	)

staticprivateinherited

Definition at line 40 of file TaskRunManager.cc.

{
    static pointer _instance = (init) ? new TaskRunManager(useTBB) : nullptr;
    return _instance;
}

References PTL::TaskRunManager::TaskRunManager().

Referenced by PTL::TaskRunManager::GetMasterRunManager(), and PTL::TaskRunManager::TaskRunManager().

◆ GetRandomNumberStatusForThisEvent()

const G4String & G4RunManager::GetRandomNumberStatusForThisEvent ( ) const

inlineinherited

Definition at line 495 of file G4RunManager.hh.

    {
      if(storeRandomNumberStatusToG4Event == 0 ||
         storeRandomNumberStatusToG4Event == 2)
      {
        G4Exception("GrRunManager::SetRandomNumberStoreDir", "Run0072",
                    JustWarning,
                    "Random number status is not available for this event.");
      }
      return randomNumberStatusForThisEvent;
    }

References G4Exception(), JustWarning, G4RunManager::randomNumberStatusForThisEvent, and G4RunManager::storeRandomNumberStatusToG4Event.

◆ GetRandomNumberStatusForThisRun()

const G4String & G4RunManager::GetRandomNumberStatusForThisRun ( ) const

inlineinherited

Definition at line 491 of file G4RunManager.hh.

    {
      return randomNumberStatusForThisRun;
    }

References G4RunManager::randomNumberStatusForThisRun.

◆ GetRandomNumberStore()

G4bool G4RunManager::GetRandomNumberStore ( ) const

inlineinherited

Definition at line 460 of file G4RunManager.hh.

    {
      return storeRandomNumberStatus;
    }

References G4RunManager::storeRandomNumberStatus.

Referenced by export_G4RunManager().

◆ GetRandomNumberStoreDir()

const G4String & G4RunManager::GetRandomNumberStoreDir ( ) const

inlineinherited

Definition at line 487 of file G4RunManager.hh.

    {
      return randomNumberStatusDir;
    }

References G4RunManager::randomNumberStatusDir.

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

◆ GetRandomNumberStorePerEvent()

G4bool G4RunManager::GetRandomNumberStorePerEvent ( ) const

inlineinherited

Definition at line 510 of file G4RunManager.hh.

    {
      return rngStatusEventsFlag;
    }

References G4RunManager::rngStatusEventsFlag.

◆ GetRunManager()

G4RunManager * G4RunManager::GetRunManager ( )

staticinherited

Definition at line 111 of file G4RunManager.cc.

{
  return fRunManager;
}

References G4RunManager::fRunManager.

◆ GetRunManagerType()

RMType G4RunManager::GetRunManagerType ( ) const

inlineinherited

Definition at line 582 of file G4RunManager.hh.

582{ return runManagerType; }

References G4RunManager::runManagerType.

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

◆ GetSelectMacro()

const G4String & G4RunManager::GetSelectMacro ( ) const

inlineinherited

Definition at line 572 of file G4RunManager.hh.

572{ return selectMacro; }

G4RunManager::selectMacro

G4String selectMacro

Definition: G4RunManager.hh:650

References G4RunManager::selectMacro.

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

◆ GetTaskManager()

TaskManager * PTL::TaskRunManager::GetTaskManager ( ) const

inlineinherited

Definition at line 72 of file TaskRunManager.hh.

72{ return m_task_manager; }

PTL::TaskRunManager::m_task_manager

TaskManager * m_task_manager

Definition: TaskRunManager.hh:92

References PTL::TaskRunManager::m_task_manager.

Referenced by G4TaskRunManagerKernel::ExecuteWorkerInit(), G4TaskRunManagerKernel::ExecuteWorkerTask(), and G4TaskRunManagerKernel::InitializeWorker().

◆ GetThreadPool()

ThreadPool * PTL::TaskRunManager::GetThreadPool ( ) const

inlineinherited

Definition at line 71 of file TaskRunManager.hh.

71{ return m_thread_pool; }

PTL::TaskRunManager::m_thread_pool

ThreadPool * m_thread_pool

Definition: TaskRunManager.hh:91

References PTL::TaskRunManager::m_thread_pool.

Referenced by PTL::internal::get_default_threadpool(), G4TaskRunManagerKernel::InitializeWorker(), and SetNumberOfThreads().

◆ GetUserActionInitialization()

const G4VUserActionInitialization * G4RunManager::GetUserActionInitialization ( ) const

inlineinherited

Definition at line 380 of file G4RunManager.hh.

    {
      return userActionInitialization;
    }

References G4RunManager::userActionInitialization.

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

◆ GetUserDetectorConstruction()

const G4VUserDetectorConstruction * G4RunManager::GetUserDetectorConstruction ( ) const

inlineinherited

Definition at line 372 of file G4RunManager.hh.

    {
      return userDetector;
    }

References G4RunManager::userDetector.

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

◆ GetUserEventAction()

const G4UserEventAction * G4RunManager::GetUserEventAction ( ) const

inlineinherited

Definition at line 404 of file G4RunManager.hh.

    {
      return userEventAction;
    }

References G4RunManager::userEventAction.

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

◆ GetUserPhysicsList()

const G4VUserPhysicsList * G4RunManager::GetUserPhysicsList ( ) const

inlineinherited

Definition at line 376 of file G4RunManager.hh.

    {
      return physicsList;
    }

References G4RunManager::physicsList.

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

◆ GetUserPrimaryGeneratorAction()

const G4VUserPrimaryGeneratorAction * G4RunManager::GetUserPrimaryGeneratorAction ( ) const

inlineinherited

Definition at line 400 of file G4RunManager.hh.

    {
      return userPrimaryGeneratorAction;
    }

References G4RunManager::userPrimaryGeneratorAction.

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

◆ GetUserRunAction()

const G4UserRunAction * G4RunManager::GetUserRunAction ( ) const

inlineinherited

Definition at line 396 of file G4RunManager.hh.

    {
      return userRunAction;
    }

References G4RunManager::userRunAction.

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

◆ GetUserStackingAction()

const G4UserStackingAction * G4RunManager::GetUserStackingAction ( ) const

inlineinherited

Definition at line 408 of file G4RunManager.hh.

    {
      return userStackingAction;
    }

References G4RunManager::userStackingAction.

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

◆ GetUserSteppingAction()

const G4UserSteppingAction * G4RunManager::GetUserSteppingAction ( ) const

inlineinherited

Definition at line 416 of file G4RunManager.hh.

    {
      return userSteppingAction;
    }

References G4RunManager::userSteppingAction.

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

◆ GetUserTrackingAction()

const G4UserTrackingAction * G4RunManager::GetUserTrackingAction ( ) const

inlineinherited

Definition at line 412 of file G4RunManager.hh.

    {
      return userTrackingAction;
    }

References G4RunManager::userTrackingAction.

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

◆ GetUserWorkerInitialization()

const G4UserWorkerInitialization * G4RunManager::GetUserWorkerInitialization ( ) const

inlineinherited

Definition at line 388 of file G4RunManager.hh.

    {
      return userWorkerInitialization;
    }

References G4RunManager::userWorkerInitialization.

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

◆ GetUserWorkerThreadInitialization()

const G4UserWorkerThreadInitialization * G4RunManager::GetUserWorkerThreadInitialization ( ) const

inlineinherited

Definition at line 392 of file G4RunManager.hh.

    {
      return userWorkerThreadInitialization;
    }

References G4RunManager::userWorkerThreadInitialization.

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

◆ GetVerbose()

int PTL::TaskRunManager::GetVerbose ( ) const

inlineinherited

Definition at line 74 of file TaskRunManager.hh.

74{ return m_verbose; }

PTL::TaskRunManager::m_verbose

int m_verbose

Definition: TaskRunManager.hh:88

References PTL::TaskRunManager::m_verbose.

Referenced by InitializeThreadPool().

◆ GetVerboseLevel()

G4int G4RunManager::GetVerboseLevel ( ) const

inlineinherited

Definition at line 520 of file G4RunManager.hh.

520{ return verboseLevel; }

References G4RunManager::verboseLevel.

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

◆ GetVersionString()

const G4String & G4RunManager::GetVersionString ( ) const

inlineinherited

Definition at line 431 of file G4RunManager.hh.

    {
      return kernel->GetVersionString();
    }

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

Referenced by export_G4RunManager().

◆ IfGeometryHasBeenDestroyed()

G4bool G4RunManager::IfGeometryHasBeenDestroyed ( )

staticinherited

Definition at line 105 of file G4RunManager.cc.

{
  return fGeometryHasBeenDestroyed;
}

References G4RunManager::fGeometryHasBeenDestroyed.

Referenced by G4WorkerTaskRunManager::RunInitialization().

◆ Initialize() [1/2]

void G4TaskRunManager::Initialize ( void )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 242 of file G4TaskRunManager.cc.

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

References G4RunManager::BeamOn(), G4RunManager::Initialize(), InitializeThreadPool(), G4RunManager::SetRunIDCounter(), and threadPool.

◆ Initialize() [2/2]

virtual void G4TaskRunManager::Initialize ( uint64_t nthreads )

inlineoverridevirtual

Reimplemented from PTL::TaskRunManager.

Definition at line 120 of file G4TaskRunManager.hh.

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

References PTL::TaskRunManager::Initialize().

◆ InitializeEventLoop()

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

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 508 of file G4TaskRunManager.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 == false && _functor == false)
      {
        G4RNGHelper* helper = G4RNGHelper::GetInstance();
        switch(SeedOncePerCommunication())
        {
          case 0:
            nSeedsFilled = n_event;
            break;
          case 1:
            nSeedsFilled = numberOfTasks;
            break;
          case 2:
            nSeedsFilled = n_event / eventModulo + 1;
            break;
          default:
            G4ExceptionDescription msgd;
            msgd << "Parameter value <" << SeedOncePerCommunication()
                 << "> of seedOncePerCommunication is invalid. It is reset "
                    "to 0.";
            G4Exception("G4TaskRunManager::InitializeEventLoop()", "Run10036",
                        JustWarning, msgd);
            SetSeedOncePerCommunication(0);
            nSeedsFilled = n_event;
        }
 
        // 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 G4UserTaskThreadInitialization();
 
  // Prepare UI commands for threads
  PrepareCommandsStack();
 
  // Start worker threads
  CreateAndStartWorkers();
}

References ComputeNumberOfTasks(), CreateAndStartWorkers(), G4MTRunManager::eventModulo, G4RunManager::fakeRun, G4TemplateRNGHelper< T >::Fill(), CLHEP::HepRandomEngine::flatArray(), G4Exception(), G4TemplateRNGHelper< T >::GetInstance(), InitializeSeeds(), initSeedsCallback, JustWarning, masterRNGEngine, G4RunManager::msgText, MTkernel, G4RunManager::n_select_msg, G4MTRunManager::nSeedsFilled, G4MTRunManager::nSeedsMax, G4MTRunManager::nSeedsPerEvent, G4MTRunManager::nSeedsUsed, G4RunManager::numberOfEventProcessed, G4MTRunManager::numberOfEventToBeProcessed, numberOfTasks, G4MTRunManager::PrepareCommandsStack(), G4MTRunManager::randDbl, G4MTRunManager::SeedOncePerCommunication(), G4RunManager::selectMacro, G4MTRunManager::SetSeedOncePerCommunication(), G4TaskRunManagerKernel::SetUpDecayChannels(), G4Timer::Start(), G4RunManager::timer, G4RunManager::userWorkerThreadInitialization, and G4RunManager::verboseLevel.

◆ InitializeGeometry()

void G4RunManager::InitializeGeometry ( )

virtualinherited

Reimplemented in G4WorkerRunManager.

Definition at line 691 of file G4RunManager.cc.

{
  if(userDetector == nullptr)
  {
    G4Exception("G4RunManager::InitializeGeometry", "Run0033", FatalException,
                "G4VUserDetectorConstruction is not defined!");
    return;
  }
 
  if(verboseLevel > 1)
    G4cout << "userDetector->Construct() start." << G4endl;
 
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState == G4State_PreInit || currentState == G4State_Idle)
  {
    stateManager->SetNewState(G4State_Init);
  }
  if(!geometryDirectlyUpdated)
  {
    kernel->DefineWorldVolume(userDetector->Construct(), false);
    userDetector->ConstructSDandField();
    nParallelWorlds = userDetector->ConstructParallelGeometries();
    userDetector->ConstructParallelSD();
    kernel->SetNumberOfParallelWorld(nParallelWorlds);
  }
  // Notify the VisManager as well
  if(G4Threading::IsMasterThread())
  {
    G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
    if(pVVisManager != nullptr)
      pVVisManager->GeometryHasChanged();
  }
 
  geometryDirectlyUpdated = false;
  geometryInitialized     = true;
  stateManager->SetNewState(currentState);
}

References G4VUserDetectorConstruction::Construct(), G4VUserDetectorConstruction::ConstructParallelGeometries(), G4VUserDetectorConstruction::ConstructParallelSD(), G4VUserDetectorConstruction::ConstructSDandField(), G4RunManagerKernel::DefineWorldVolume(), FatalException, G4cout, G4endl, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, G4RunManager::geometryDirectlyUpdated, G4VVisManager::GeometryHasChanged(), G4RunManager::geometryInitialized, G4VVisManager::GetConcreteInstance(), G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4Threading::IsMasterThread(), G4RunManager::kernel, G4RunManager::nParallelWorlds, G4StateManager::SetNewState(), G4RunManagerKernel::SetNumberOfParallelWorld(), G4RunManager::userDetector, and G4RunManager::verboseLevel.

Referenced by G4RunManager::Initialize().

◆ InitializePhysics()

void G4RunManager::InitializePhysics ( )

virtualinherited

Definition at line 731 of file G4RunManager.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState == G4State_PreInit || currentState == G4State_Idle)
  {
    stateManager->SetNewState(G4State_Init);
  }
  if(physicsList != nullptr)
  {
    kernel->InitializePhysics();
  }
  else
  {
    G4Exception("G4RunManager::InitializePhysics()", "Run0034", FatalException,
                "G4VUserPhysicsList is not defined!");
  }
  physicsInitialized = true;
  stateManager->SetNewState(currentState);
}

References FatalException, G4Exception(), G4State_Idle, G4State_Init, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), G4RunManagerKernel::InitializePhysics(), G4RunManager::kernel, G4RunManager::physicsInitialized, G4RunManager::physicsList, and G4StateManager::SetNewState().

Referenced by G4RunManager::Initialize().

◆ InitializeSeeds()

virtual G4bool G4TaskRunManager::InitializeSeeds ( G4int )

inlineoverrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 155 of file G4TaskRunManager.hh.

155{ return false; }

Referenced by InitializeEventLoop().

◆ InitializeThreadPool()

void G4TaskRunManager::InitializeThreadPool ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 259 of file G4TaskRunManager.cc.

{
  if(poolInitialized && threadPool && workTaskGroup)
  {
    G4Exception("G4TaskRunManager::InitializeThreadPool", "Run1040",
                JustWarning, "Threadpool already initialized. Ignoring...");
    return;
  }
 
  PTL::TaskRunManager::SetVerbose(GetVerbose());
  PTL::TaskRunManager::Initialize(nworkers);
 
  // create the joiners
  if(!workTaskGroup)
  { workTaskGroup = new RunTaskGroup(threadPool); }
 
  if(verboseLevel > 0)
  {
    std::stringstream ss;
    ss.fill('=');
    ss << std::setw(90) << "";
    G4cout << "\n" << ss.str() << G4endl;
 
    if(threadPool->is_tbb_threadpool())
    {
      G4cout << "G4TaskRunManager :: Using TBB..." << G4endl;
    }
    else
    {
      G4cout << "G4TaskRunManager :: Using G4ThreadPool..." << G4endl;
    }
 
    G4cout << ss.str() << "\n" << G4endl;
  }
}

References G4cout, G4endl, G4Exception(), PTL::TaskRunManager::GetVerbose(), PTL::TaskRunManager::Initialize(), PTL::ThreadPool::is_tbb_threadpool(), JustWarning, G4MTRunManager::nworkers, poolInitialized, PTL::TaskRunManager::SetVerbose(), threadPool, G4RunManager::verboseLevel, and workTaskGroup.

Referenced by Initialize().

◆ IsInitialized()

bool PTL::TaskRunManager::IsInitialized ( ) const

inlineinherited

Definition at line 73 of file TaskRunManager.hh.

73{ return m_is_initialized; }

PTL::TaskRunManager::m_is_initialized

bool m_is_initialized

Definition: TaskRunManager.hh:87

References PTL::TaskRunManager::m_is_initialized.

◆ MergeRun()

void G4TaskRunManager::MergeRun ( const G4Run * localRun )

Definition at line 642 of file G4TaskRunManager.cc.

{
  G4AutoLock l(&runMergerMutex);
  if(currentRun)
    currentRun->Merge(localRun);
}

References G4RunManager::currentRun, G4Run::Merge(), and anonymous_namespace{G4TaskRunManager.cc}::runMergerMutex.

◆ MergeScores()

void G4TaskRunManager::MergeScores ( const G4ScoringManager * localScoringManager )

Definition at line 633 of file G4TaskRunManager.cc.

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

References G4MTRunManager::masterScM, G4ScoringManager::Merge(), and anonymous_namespace{G4TaskRunManager.cc}::scorerMergerMutex.

◆ NewActionRequest()

virtual void G4TaskRunManager::NewActionRequest ( WorkerActionRequest )

inlineoverrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 205 of file G4TaskRunManager.hh.

205{}

◆ PhysicsHasBeenModified()

void G4RunManager::PhysicsHasBeenModified ( )

inlineinherited

Definition at line 294 of file G4RunManager.hh.

294{ kernel->PhysicsHasBeenModified(); }

G4RunManagerKernel::PhysicsHasBeenModified

void PhysicsHasBeenModified()

Definition: G4RunManagerKernel.hh:124

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

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

◆ PrepareCommandsStack()

void G4MTRunManager::PrepareCommandsStack ( )

protectedvirtualinherited

Definition at line 310 of file G4MTRunManager.cc.

{
  G4AutoLock l(&cmdHandlingMutex);
  uiCmdsForWorkers.clear();
  std::vector<G4String>* cmdCopy =
    G4UImanager::GetUIpointer()->GetCommandStack();
  for(auto it = cmdCopy->cbegin(); it != cmdCopy->cend(); ++it)
    uiCmdsForWorkers.push_back(*it);
  cmdCopy->clear();
  delete cmdCopy;
}

References anonymous_namespace{G4MTRunManager.cc}::cmdHandlingMutex, G4UImanager::GetCommandStack(), G4UImanager::GetUIpointer(), and G4MTRunManager::uiCmdsForWorkers.

Referenced by G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4MTRunManager::RequestWorkersProcessCommandsStack(), and RequestWorkersProcessCommandsStack().

◆ ProcessOneEvent()

void G4TaskRunManager::ProcessOneEvent ( G4int i_event )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 297 of file G4TaskRunManager.cc.

{
  // Nothing to do
}

◆ RefillSeeds()

void G4TaskRunManager::RefillSeeds ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

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

References G4MTRunManager::eventModulo, CLHEP::HepRandomEngine::flatArray(), G4TemplateRNGHelper< T >::GetInstance(), masterRNGEngine, G4MTRunManager::nSeedsFilled, G4MTRunManager::nSeedsMax, G4MTRunManager::nSeedsPerEvent, G4MTRunManager::numberOfEventToBeProcessed, numberOfTasks, G4MTRunManager::randDbl, G4TemplateRNGHelper< T >::Refill(), and G4MTRunManager::SeedOncePerCommunication().

Referenced by SetUpAnEvent(), and SetUpNEvents().

◆ ReinitializeGeometry()

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

inherited

Definition at line 1130 of file G4RunManager.cc.

{
  if(destroyFirst && G4Threading::IsMasterThread())
  {
    if(verboseLevel > 0)
    {
      G4cout << "#### Assemblies, Volumes and Solids Stores are wiped out."
             << G4endl;
    }
    G4GeometryManager::GetInstance()->OpenGeometry();
    G4AssemblyStore::GetInstance()->Clean();
    G4PhysicalVolumeStore::GetInstance()->Clean();
    G4LogicalVolumeStore::GetInstance()->Clean();
    G4SolidStore::GetInstance()->Clean();
 
    // remove all logical volume pointers from regions
    // exception: world logical volume pointer must be kept
    G4RegionStore* regionStore = G4RegionStore::GetInstance();
    for(auto rItr = regionStore->cbegin(); rItr != regionStore->cend(); ++rItr)
    {
      if((*rItr)->GetName() == "DefaultRegionForTheWorld")
        continue;
      // if((*rItr)->GetName()=="DefaultRegionForParallelWorld") continue;
      auto lvItr = (*rItr)->GetRootLogicalVolumeIterator();
      for(std::size_t iRLV=0; iRLV<(*rItr)->GetNumberOfRootVolumes(); ++iRLV)
      {
        (*rItr)->RemoveRootLogicalVolume(*lvItr, false);
        ++lvItr;
      }
      if(verboseLevel > 0)
      {
        G4cout << "#### Region <" << (*rItr)->GetName() << "> is cleared."
               << G4endl;
      }
    }
 
    // clear transportation manager
    fGeometryHasBeenDestroyed = true;
    G4TransportationManager::GetTransportationManager()->ClearParallelWorlds();
  }
  if(prop)
  {
    G4UImanager::GetUIpointer()->ApplyCommand("/run/reinitializeGeometry");
  }
  else
  {
    kernel->GeometryHasBeenModified();
    geometryInitialized = false;
    // Notify the VisManager as well
    if(G4Threading::IsMasterThread())
    {
      G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
      if(pVVisManager != nullptr)
        pVVisManager->GeometryHasChanged();
    }
  }
}

References G4UImanager::ApplyCommand(), G4LogicalVolumeStore::Clean(), G4PhysicalVolumeStore::Clean(), G4SolidStore::Clean(), G4AssemblyStore::Clean(), G4TransportationManager::ClearParallelWorlds(), G4RunManager::fGeometryHasBeenDestroyed, G4cout, G4endl, G4RunManagerKernel::GeometryHasBeenModified(), G4VVisManager::GeometryHasChanged(), G4RunManager::geometryInitialized, G4VVisManager::GetConcreteInstance(), G4GeometryManager::GetInstance(), G4LogicalVolumeStore::GetInstance(), G4PhysicalVolumeStore::GetInstance(), G4RegionStore::GetInstance(), G4SolidStore::GetInstance(), G4AssemblyStore::GetInstance(), G4TransportationManager::GetTransportationManager(), G4UImanager::GetUIpointer(), G4Threading::IsMasterThread(), G4RunManager::kernel, G4GeometryManager::OpenGeometry(), and G4RunManager::verboseLevel.

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

◆ ReOptimize()

void G4RunManager::ReOptimize ( G4LogicalVolume * pLog )

inherited

Definition at line 1009 of file G4RunManager.cc.

{
  G4Timer localtimer;
  if(verboseLevel > 1)
  {
    localtimer.Start();
  }
  G4SmartVoxelHeader* header = pLog->GetVoxelHeader();
  delete header;
  header = new G4SmartVoxelHeader(pLog);
  pLog->SetVoxelHeader(header);
  if(verboseLevel > 1)
  {
    localtimer.Stop();
    G4SmartVoxelStat stat(pLog, header, localtimer.GetSystemElapsed(),
                          localtimer.GetUserElapsed());
    G4cout << G4endl << "Voxelisation of logical volume <" << pLog->GetName()
           << ">" << G4endl;
    G4cout << " heads : " << stat.GetNumberHeads()
           << " - nodes : " << stat.GetNumberNodes()
           << " - pointers : " << stat.GetNumberPointers() << G4endl;
    G4cout << " Memory used : " << (stat.GetMemoryUse() + 512) / 1024
           << "k - total time : " << stat.GetTotalTime()
           << " - system time : " << stat.GetSysTime() << G4endl;
  }
}

References G4cout, G4endl, G4SmartVoxelStat::GetMemoryUse(), G4LogicalVolume::GetName(), G4SmartVoxelStat::GetNumberHeads(), G4SmartVoxelStat::GetNumberNodes(), G4SmartVoxelStat::GetNumberPointers(), G4Timer::GetSystemElapsed(), G4SmartVoxelStat::GetSysTime(), G4SmartVoxelStat::GetTotalTime(), G4Timer::GetUserElapsed(), G4LogicalVolume::GetVoxelHeader(), G4LogicalVolume::SetVoxelHeader(), G4Timer::Start(), G4Timer::Stop(), and G4RunManager::verboseLevel.

Referenced by G4RunManager::ReOptimizeMotherOf().

◆ ReOptimizeMotherOf()

void G4RunManager::ReOptimizeMotherOf ( G4VPhysicalVolume * pPhys )

inherited

Definition at line 1001 of file G4RunManager.cc.

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

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

◆ RequestWorkersProcessCommandsStack()

void G4TaskRunManager::RequestWorkersProcessCommandsStack ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 772 of file G4TaskRunManager.cc.

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

References G4UImanager::ApplyCommand(), PTL::ThreadPool::execute_on_all_threads(), G4MTRunManager::GetCommandStack(), G4MTRunManager::GetMasterRunManager(), G4UImanager::GetUIpointer(), G4MTRunManager::PrepareCommandsStack(), G4MTRunManager::ThisWorkerProcessCommandsStackDone(), and threadPool.

Referenced by TerminateWorkers().

◆ RestoreRandomNumberStatus()

void G4RunManager::RestoreRandomNumberStatus ( const G4String & fileN )

virtualinherited

Definition at line 870 of file G4RunManager.cc.

{
  G4String fileNameWithDirectory;
  if(fileN.find("/") == std::string::npos)
  {
    fileNameWithDirectory = randomNumberStatusDir + fileN;
  }
  else
  {
    fileNameWithDirectory = fileN;
  }
 
  G4Random::restoreEngineStatus(fileNameWithDirectory);
  if(verboseLevel > 0)
    G4cout << "RandomNumberEngineStatus restored from file: "
           << fileNameWithDirectory << G4endl;
  G4Random::showEngineStatus();
}

References G4cout, G4endl, G4RunManager::randomNumberStatusDir, and G4RunManager::verboseLevel.

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

◆ RestoreRndmEachEvent()

virtual void G4RunManager::RestoreRndmEachEvent ( G4bool )

inlinevirtualinherited

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 346 of file G4RunManager.hh.

346{ /* No effect in SEQ */ }

Referenced by G4RunMessenger::SetNewValue().

◆ rndmSaveThisEvent()

void G4MTRunManager::rndmSaveThisEvent ( )

protectedvirtualinherited

Reimplemented from G4RunManager.

Definition at line 254 of file G4MTRunManager.cc.

{
  G4Exception("G4MTRunManager::rndmSaveThisEvent", "RUN_RNDM001",
              FatalException, "This method shall not be invoked !!");
}

References FatalException, and G4Exception().

◆ rndmSaveThisRun()

void G4MTRunManager::rndmSaveThisRun ( )

protectedvirtualinherited

Reimplemented from G4RunManager.

Definition at line 221 of file G4MTRunManager.cc.

{
  G4int runNumber = 0;
  if(currentRun != nullptr)
    runNumber = currentRun->GetRunID();
  if(!storeRandomNumberStatus)
  {
    G4cerr << "Warning from G4RunManager::rndmSaveThisRun():"
           << " Random number status was not stored prior to this run."
           << G4endl << "/random/setSavingFlag command must be issued. "
           << "Command ignored." << G4endl;
    return;
  }
 
  G4String fileIn = randomNumberStatusDir + "G4Worker_currentRun.rndm";
 
  std::ostringstream os;
  os << "run" << runNumber << ".rndm" << '\0';
  G4String fileOut = randomNumberStatusDir + os.str();
 
#ifdef WIN32
  G4String copCmd = "/control/shell copy " + fileIn + " " + fileOut;
#else
  G4String copCmd = "/control/shell cp " + fileIn + " " + fileOut;
#endif
  G4UImanager::GetUIpointer()->ApplyCommand(copCmd);
  if(verboseLevel > 0)
  {
    G4cout << fileIn << " is copied to " << fileOut << G4endl;
  }
}

References G4UImanager::ApplyCommand(), G4RunManager::currentRun, G4cerr, G4cout, G4endl, G4Run::GetRunID(), G4UImanager::GetUIpointer(), G4RunManager::randomNumberStatusDir, G4RunManager::storeRandomNumberStatus, and G4RunManager::verboseLevel.

◆ RunInitialization()

void G4RunManager::RunInitialization ( )

virtualinherited

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 332 of file G4RunManager.cc.

{
  if(!(kernel->RunInitialization(fakeRun)))
    return;
 
  runAborted             = false;
  numberOfEventProcessed = 0;
 
  CleanUpPreviousEvents();
  delete currentRun;
  currentRun = nullptr;
 
  if(fakeRun)
    return;
 
  if(fGeometryHasBeenDestroyed)
    G4ParallelWorldProcessStore::GetInstance()->UpdateWorlds();
 
  if(userRunAction != nullptr)
    currentRun = userRunAction->GenerateRun();
  if(currentRun == nullptr)
    currentRun = new G4Run();
 
  currentRun->SetRunID(runIDCounter);
  currentRun->SetNumberOfEventToBeProcessed(numberOfEventToBeProcessed);
 
  currentRun->SetDCtable(DCtable);
  G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
  if(fSDM != nullptr)
  {
    currentRun->SetHCtable(fSDM->GetHCtable());
  }
 
  if(G4VScoreNtupleWriter::Instance() != nullptr)
  {
    auto hce            = fSDM->PrepareNewEvent();
    isScoreNtupleWriter = G4VScoreNtupleWriter::Instance()->Book(hce);
    delete hce;
  }
 
  std::ostringstream oss;
  G4Random::saveFullState(oss);
  randomNumberStatusForThisRun = oss.str();
  currentRun->SetRandomNumberStatus(randomNumberStatusForThisRun);
 
  for(G4int i_prev = 0; i_prev < n_perviousEventsToBeStored; ++i_prev)
  {
    previousEvents->push_back(nullptr);
  }
 
  if(printModulo >= 0 || verboseLevel > 0)
  {
    G4cout << "### Run " << currentRun->GetRunID() << " starts." << G4endl;
  }
  if(userRunAction != nullptr)
    userRunAction->BeginOfRunAction(currentRun);
 
#if defined(GEANT4_USE_TIMEMORY)
  masterRunProfiler.reset(new ProfilerConfig(currentRun));
#endif
 
  if(isScoreNtupleWriter)
  {
    G4VScoreNtupleWriter::Instance()->OpenFile();
  }
 
  if(storeRandomNumberStatus)
  {
    G4String fileN = "currentRun";
    if(rngStatusEventsFlag)
    {
      std::ostringstream os;
      os << "run" << currentRun->GetRunID();
      fileN = os.str();
    }
    StoreRNGStatus(fileN);
  }
}

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

Referenced by G4RunManager::BeamOn().

◆ RunTermination()

void G4TaskRunManager::RunTermination ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 598 of file G4TaskRunManager.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
 
  // Wait now for all threads to finish event-loop
  WaitForEndEventLoopWorkers();
  // Now call base-class methof
  G4RunManager::TerminateEventLoop();
  G4RunManager::RunTermination();
}

References G4RunManager::RunTermination(), G4RunManager::TerminateEventLoop(), and WaitForEndEventLoopWorkers().

◆ SeedOncePerCommunication()

G4int G4MTRunManager::SeedOncePerCommunication ( )

staticinherited

Definition at line 108 of file G4MTRunManager.cc.

{
  return seedOncePerCommunication;
}

References G4MTRunManager::seedOncePerCommunication.

Referenced by G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), G4RunMessenger::GetCurrentValue(), InitializeEventLoop(), RefillSeeds(), and SetUpNEvents().

◆ SetDCtable()

void G4RunManager::SetDCtable ( G4DCtable * DCtbl )

inlineinherited

Definition at line 573 of file G4RunManager.hh.

573{ DCtable = DCtbl; }

References G4RunManager::DCtable.

Referenced by G4DigiManager::AddNewModule().

◆ SetEventModulo()

void G4MTRunManager::SetEventModulo ( G4int i = 1 )

inlineinherited

Definition at line 187 of file G4MTRunManager.hh.

187{ eventModuloDef = i; }

References G4MTRunManager::eventModuloDef.

◆ SetGeometryToBeOptimized()

void G4RunManager::SetGeometryToBeOptimized ( G4bool vl )

inlineinherited

Definition at line 317 of file G4RunManager.hh.

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

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

Referenced by G4RunMessenger::SetNewValue().

◆ SetGrainsize()

void G4TaskRunManager::SetGrainsize ( G4int n )

inline

Definition at line 92 of file G4TaskRunManager.hh.

92{ eventGrainsize = n; }

CLHEP::detail::n

n

Definition: Ranlux64Engine.cc:90

References eventGrainsize, and CLHEP::detail::n.

◆ SetInitializeSeedsCallback()

void G4TaskRunManager::SetInitializeSeedsCallback ( InitializeSeedsCallback f )

inline

Definition at line 209 of file G4TaskRunManager.hh.

  {
    initSeedsCallback = f;
  }

References initSeedsCallback.

◆ SetNumberOfAdditionalWaitingStacks()

void G4RunManager::SetNumberOfAdditionalWaitingStacks ( G4int iAdd )

inlineinherited

Definition at line 422 of file G4RunManager.hh.

    {
      eventManager->SetNumberOfAdditionalWaitingStacks(iAdd);
    }

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

◆ SetNumberOfEventsToBeProcessed()

void G4RunManager::SetNumberOfEventsToBeProcessed ( G4int val )

inlineinherited

Definition at line 563 of file G4RunManager.hh.

    {
      numberOfEventToBeProcessed = val;
    }

References G4RunManager::numberOfEventToBeProcessed.

◆ SetNumberOfEventsToBeStored()

void G4RunManager::SetNumberOfEventsToBeStored ( G4int val )

inlineinherited

Definition at line 524 of file G4RunManager.hh.

    {
      n_perviousEventsToBeStored = val;
    }

References G4RunManager::n_perviousEventsToBeStored.

◆ SetNumberOfThreads()

void G4TaskRunManager::SetNumberOfThreads ( G4int n )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 208 of file G4TaskRunManager.cc.

{
  if(forcedNwokers > 0)
  {
    if(verboseLevel > 0)
    {
      G4ExceptionDescription msg;
      msg << "\n### Number of threads is forced to " << forcedNwokers
       << " by G4FORCENUMBEROFTHREADS environment variable. G4TaskRunManager::"
       << __FUNCTION__ << "(" << n << ") ignored ###";
      G4Exception("G4TaskRunManager::SetNumberOfThreads(G4int)", "Run0132",
                  JustWarning, msg);
    }
    nworkers = forcedNwokers;
  }
  else
  {
    nworkers = n;
    if(poolInitialized)
    {
      if(verboseLevel > 0)
      {
         std::stringstream ss;
         ss << "\n### Thread-pool already initialized. Resizing  to " << nworkers
            << "threads ###";
         G4cout << ss.str() << "\n" << G4endl;
      }
      GetThreadPool()->resize(n);
    }
  }
}

References G4MTRunManager::forcedNwokers, G4cout, G4endl, G4Exception(), PTL::TaskRunManager::GetThreadPool(), JustWarning, CLHEP::detail::n, G4MTRunManager::nworkers, poolInitialized, PTL::ThreadPool::resize(), and G4RunManager::verboseLevel.

◆ SetPinAffinity()

void G4MTRunManager::SetPinAffinity ( G4int n = 1 )

inherited

Definition at line 807 of file G4MTRunManager.cc.

{
  if(n == 0)
  {
    G4Exception("G4MTRunManager::SetPinAffinity", "Run0114", FatalException,
                "Pin affinity must be >0 or <0.");
  }
  pinAffinity = n;
  return;
}

References FatalException, G4Exception(), CLHEP::detail::n, and G4MTRunManager::pinAffinity.

◆ SetPrimaryTransformer()

void G4RunManager::SetPrimaryTransformer ( G4PrimaryTransformer * pt )

inlineinherited

Definition at line 436 of file G4RunManager.hh.

    {
      kernel->SetPrimaryTransformer(pt);
    }

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

◆ SetPrintProgress()

void G4RunManager::SetPrintProgress ( G4int i )

inlineinherited

Definition at line 522 of file G4RunManager.hh.

522{ printModulo = i; }

References G4RunManager::printModulo.

Referenced by G4RunMessenger::SetNewValue().

◆ SetRandomNumberStore()

void G4RunManager::SetRandomNumberStore ( G4bool flag )

inlineinherited

Definition at line 456 of file G4RunManager.hh.

    {
      storeRandomNumberStatus = flag;
    }

References G4RunManager::storeRandomNumberStatus.

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

◆ SetRandomNumberStoreDir()

void G4RunManager::SetRandomNumberStoreDir ( const G4String & dir )

inlineinherited

Definition at line 464 of file G4RunManager.hh.

    {
      G4String dirStr = dir;
      if(dirStr.back() != '/')
        dirStr += "/";
    #ifndef WIN32
      G4String shellCmd = "mkdir -p ";
    #else
      std::replace(dirStr.begin(), dirStr.end(), '/', '\\');
      G4String shellCmd = "if not exist " + dirStr + " mkdir ";
    #endif
      shellCmd += dirStr;
      randomNumberStatusDir = dirStr;
      G4int sysret          = system(shellCmd);
      if(sysret != 0)
      {
        G4String errmsg = "\"" + shellCmd
                 + "\" returns non-zero value. Directory creation failed.";
        G4Exception("GrRunManager::SetRandomNumberStoreDir", "Run0071",
                    JustWarning, errmsg);
        G4cerr << " return value = " << sysret << G4endl;
      }
    }

References G4cerr, G4endl, G4Exception(), JustWarning, and G4RunManager::randomNumberStatusDir.

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

◆ SetRandomNumberStorePerEvent()

void G4RunManager::SetRandomNumberStorePerEvent ( G4bool flag )

inlineinherited

Definition at line 506 of file G4RunManager.hh.

    {
      rngStatusEventsFlag = flag;
    }

References G4RunManager::rngStatusEventsFlag.

Referenced by G4RunMessenger::SetNewValue().

◆ SetRunIDCounter()

void G4RunManager::SetRunIDCounter ( G4int i )

inlineinherited

Definition at line 558 of file G4RunManager.hh.

558{ runIDCounter = i; }

References G4RunManager::runIDCounter.

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

◆ SetSeedOncePerCommunication()

void G4MTRunManager::SetSeedOncePerCommunication ( G4int val )

staticinherited

Definition at line 114 of file G4MTRunManager.cc.

{
  seedOncePerCommunication = val;
}

References G4MTRunManager::seedOncePerCommunication.

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

◆ SetUpAnEvent()

G4bool G4TaskRunManager::SetUpAnEvent	(	G4Event *	evt,
		G4long &	s1,
		G4long &	s2,
		G4long &	s3,
		G4bool	reseedRequired = `true`
	)

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 651 of file G4TaskRunManager.cc.

{
  G4AutoLock l(&setUpEventMutex);
  if(numberOfEventProcessed < numberOfEventToBeProcessed)
  {
    evt->SetEventID(numberOfEventProcessed);
    if(reseedRequired)
    {
      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();
    }
    numberOfEventProcessed++;
    return true;
  }
  return false;
}

References G4TemplateRNGHelper< T >::GetInstance(), G4TemplateRNGHelper< T >::GetSeed(), G4MTRunManager::nSeedsFilled, G4MTRunManager::nSeedsPerEvent, G4MTRunManager::nSeedsUsed, G4RunManager::numberOfEventProcessed, G4MTRunManager::numberOfEventToBeProcessed, RefillSeeds(), G4Event::SetEventID(), and anonymous_namespace{G4TaskRunManager.cc}::setUpEventMutex.

◆ SetUpNEvents()

G4int G4TaskRunManager::SetUpNEvents	(	G4Event *	evt,
		G4SeedsQueue *	seedsQueue,
		G4bool	reseedRequired = `true`
	)

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 678 of file G4TaskRunManager.cc.

{
  G4AutoLock l(&setUpEventMutex);
  if(numberOfEventProcessed < numberOfEventToBeProcessed && !runAborted)
  {
    G4int nevt = numberOfEventsPerTask;
    G4int nmod = eventModulo;
    if(numberOfEventProcessed + nevt > numberOfEventToBeProcessed)
    {
      nevt = numberOfEventToBeProcessed - numberOfEventProcessed;
      nmod = numberOfEventToBeProcessed - numberOfEventProcessed;
    }
    evt->SetEventID(numberOfEventProcessed);
 
    if(reseedRequired)
    {
      G4RNGHelper* helper = G4RNGHelper::GetInstance();
      G4int nevRnd        = nmod;
      if(SeedOncePerCommunication() > 0)
        nevRnd = 1;
      for(G4int i = 0; i < nevRnd; ++i)
      {
        seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed));
        seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed + 1));
        if(nSeedsPerEvent == 3)
          seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed + 2));
        nSeedsUsed++;
        if(nSeedsUsed == nSeedsFilled)
          RefillSeeds();
      }
    }
    numberOfEventProcessed += nevt;
    return nevt;
  }
  return 0;
}

References G4MTRunManager::eventModulo, G4TemplateRNGHelper< T >::GetInstance(), G4TemplateRNGHelper< T >::GetSeed(), G4MTRunManager::nSeedsFilled, G4MTRunManager::nSeedsPerEvent, G4MTRunManager::nSeedsUsed, G4RunManager::numberOfEventProcessed, numberOfEventsPerTask, G4MTRunManager::numberOfEventToBeProcessed, RefillSeeds(), G4RunManager::runAborted, G4MTRunManager::SeedOncePerCommunication(), G4Event::SetEventID(), and anonymous_namespace{G4TaskRunManager.cc}::setUpEventMutex.

◆ SetUserAction() [1/6]

void G4MTRunManager::SetUserAction ( G4UserEventAction * userAction )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 589 of file G4MTRunManager.cc.

{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0124", FatalException,
              "For multi-threaded version, define G4UserEventAction in "
              "G4VUserActionInitialization.");
}

References FatalException, and G4Exception().

◆ SetUserAction() [2/6]

void G4MTRunManager::SetUserAction ( G4UserRunAction * userAction )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 571 of file G4MTRunManager.cc.

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

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

Referenced by G4TheMTRayTracer::RestoreUserActions(), and G4TheMTRayTracer::StoreUserActions().

◆ SetUserAction() [3/6]

void G4MTRunManager::SetUserAction ( G4UserStackingAction * userAction )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 597 of file G4MTRunManager.cc.

{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0125", FatalException,
              "For multi-threaded version, define G4UserStackingAction in "
              "G4VUserActionInitialization.");
}

References FatalException, and G4Exception().

◆ SetUserAction() [4/6]

void G4MTRunManager::SetUserAction ( G4UserSteppingAction * userAction )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 613 of file G4MTRunManager.cc.

{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0127", FatalException,
              "For multi-threaded version, define G4UserSteppingAction in "
              "G4VUserActionInitialization.");
}

References FatalException, and G4Exception().

◆ SetUserAction() [5/6]

void G4MTRunManager::SetUserAction ( G4UserTrackingAction * userAction )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 605 of file G4MTRunManager.cc.

{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0126", FatalException,
              "For multi-threaded version, define G4UserTrackingAction in "
              "G4VUserActionInitialization.");
}

References FatalException, and G4Exception().

◆ SetUserAction() [6/6]

void G4MTRunManager::SetUserAction ( G4VUserPrimaryGeneratorAction * userAction )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 579 of file G4MTRunManager.cc.

{
  G4Exception(
    "G4MTRunManager::SetUserAction()", "Run0123", FatalException,
    "For multi-threaded version, define G4VUserPrimaryGeneratorAction in "
    "G4VUserActionInitialization.");
}

References FatalException, and G4Exception().

◆ SetUserInitialization() [1/5]

void G4MTRunManager::SetUserInitialization ( G4UserWorkerInitialization * userInit )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 537 of file G4MTRunManager.cc.

{
  userWorkerInitialization = userInit;
}

References G4RunManager::userWorkerInitialization.

◆ SetUserInitialization() [2/5]

void G4MTRunManager::SetUserInitialization ( G4UserWorkerThreadInitialization * userInit )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 543 of file G4MTRunManager.cc.

{
  userWorkerThreadInitialization = userInit;
}

References G4RunManager::userWorkerThreadInitialization.

◆ SetUserInitialization() [3/5]

void G4MTRunManager::SetUserInitialization ( G4VUserActionInitialization * userInit )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 550 of file G4MTRunManager.cc.

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

References G4VUserActionInitialization::BuildForMaster(), and G4RunManager::userActionInitialization.

◆ SetUserInitialization() [4/5]

void G4MTRunManager::SetUserInitialization ( G4VUserDetectorConstruction * userDC )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 565 of file G4MTRunManager.cc.

{
  G4RunManager::SetUserInitialization(userDC);
}

References G4RunManager::SetUserInitialization().

◆ SetUserInitialization() [5/5]

void G4MTRunManager::SetUserInitialization ( G4VUserPhysicsList * userPL )

virtualinherited

Reimplemented from G4RunManager.

Definition at line 558 of file G4MTRunManager.cc.

{
  G4RunManager::SetUserInitialization(userPL);
  // Needed for MT, to be moved in kernel
}

References G4RunManager::SetUserInitialization().

Referenced by G4TheMTRayTracer::RestoreUserActions(), and G4TheMTRayTracer::StoreUserActions().

◆ SetVerbose()

void PTL::TaskRunManager::SetVerbose ( int val )

inlineinherited

Definition at line 75 of file TaskRunManager.hh.

75{ m_verbose = val; }

References PTL::TaskRunManager::m_verbose.

Referenced by InitializeThreadPool().

◆ SetVerboseLevel()

void G4RunManager::SetVerboseLevel ( G4int vl )

inlineinherited

Definition at line 515 of file G4RunManager.hh.

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

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

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

◆ StackPreviousEvent()

void G4RunManager::StackPreviousEvent ( G4Event * anEvent )

protectedinherited

Definition at line 646 of file G4RunManager.cc.

{
  if(anEvent->ToBeKept())
    currentRun->StoreEvent(anEvent);
 
  if(n_perviousEventsToBeStored == 0)
  {
    if(anEvent->GetNumberOfGrips() == 0)
    {
      if(!(anEvent->ToBeKept()))
        delete anEvent;
    }
    else
    {
      previousEvents->push_back(anEvent);
    }
  }
  CleanUpUnnecessaryEvents(n_perviousEventsToBeStored);
}

References G4RunManager::CleanUpUnnecessaryEvents(), G4RunManager::currentRun, G4Event::GetNumberOfGrips(), G4RunManager::n_perviousEventsToBeStored, G4RunManager::previousEvents, G4Run::StoreEvent(), and G4Event::ToBeKept().

Referenced by G4RunManager::TerminateOneEvent().

◆ StoreRandomNumberStatusToG4Event()

void G4RunManager::StoreRandomNumberStatusToG4Event ( G4int vl )

inlineinherited

Definition at line 441 of file G4RunManager.hh.

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

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

Referenced by G4RunMessenger::SetNewValue().

◆ StoreRNGStatus()

void G4TaskRunManager::StoreRNGStatus ( const G4String & filenamePrefix )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 199 of file G4TaskRunManager.cc.

{
  std::ostringstream os;
  os << randomNumberStatusDir << "G4Master_" << fn << ".rndm";
  G4Random::saveEngineStatus(os.str().c_str());
}

References G4RunManager::randomNumberStatusDir.

◆ Terminate()

void TaskRunManager::Terminate ( )

virtualinherited

Definition at line 133 of file TaskRunManager.cc.

{
    m_is_initialized = false;
    if(m_thread_pool)
        m_thread_pool->destroy_threadpool();
    delete m_task_manager;
    delete m_thread_pool;
    m_task_manager = nullptr;
    m_thread_pool  = nullptr;
}

References PTL::ThreadPool::destroy_threadpool(), PTL::TaskRunManager::m_is_initialized, PTL::TaskRunManager::m_task_manager, and PTL::TaskRunManager::m_thread_pool.

Referenced by ~G4TaskRunManager().

◆ TerminateEventLoop()

void G4RunManager::TerminateEventLoop ( )

virtualinherited

Reimplemented in G4WorkerRunManager, and G4WorkerTaskRunManager.

Definition at line 477 of file G4RunManager.cc.

{
  if(verboseLevel > 0 && !fakeRun)
  {
    timer->Stop();
    G4cout << " Run terminated." << G4endl;
    G4cout << "Run Summary" << G4endl;
    if(runAborted)
    {
      G4cout << "  Run Aborted after " << numberOfEventProcessed
             << " events processed." << G4endl;
    }
    else
    {
      G4cout << "  Number of events processed : " << numberOfEventProcessed
             << G4endl;
    }
    G4cout << "  " << *timer << G4endl;
  }
  fGeometryHasBeenDestroyed = false;
}

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

Referenced by G4RunManager::DoEventLoop(), G4MTRunManager::RunTermination(), and RunTermination().

◆ TerminateOneEvent()

void G4TaskRunManager::TerminateOneEvent ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 304 of file G4TaskRunManager.cc.

{
  // Nothing to do
}

◆ TerminateWorkers()

void G4TaskRunManager::TerminateWorkers ( )

overrideprotectedvirtual

Reimplemented from G4MTRunManager.

Definition at line 718 of file G4TaskRunManager.cc.

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

References PTL::ThreadPool::execute_on_all_threads(), G4RunManager::fakeRun, PTL::TaskGroup< Tp, Arg, MaxDepth >::join(), RequestWorkersProcessCommandsStack(), G4TaskRunManagerKernel::TerminateWorker(), threadPool, and workTaskGroup.

Referenced by ~G4TaskRunManager().

◆ ThisWorkerEndEventLoop()

virtual void G4TaskRunManager::ThisWorkerEndEventLoop ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 198 of file G4TaskRunManager.hh.

198{}

◆ ThisWorkerProcessCommandsStackDone()

void G4TaskRunManager::ThisWorkerProcessCommandsStackDone ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 793 of file G4TaskRunManager.cc.

793{}

◆ ThisWorkerReady()

virtual void G4TaskRunManager::ThisWorkerReady ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 197 of file G4TaskRunManager.hh.

197{}

◆ ThisWorkerWaitForNextAction()

virtual WorkerActionRequest G4TaskRunManager::ThisWorkerWaitForNextAction ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 199 of file G4TaskRunManager.hh.

  {
    return WorkerActionRequest::UNDEFINED;
  }

References G4MTRunManager::UNDEFINED.

◆ ThreadPoolIsInitialized()

G4bool G4TaskRunManager::ThreadPoolIsInitialized ( ) const

inline

Definition at line 118 of file G4TaskRunManager.hh.

118{ return poolInitialized; }

References poolInitialized.

◆ UpdateScoring()

void G4RunManager::UpdateScoring ( )

protectedinherited

Definition at line 973 of file G4RunManager.cc.

{
  if(isScoreNtupleWriter)
  {
    G4VScoreNtupleWriter::Instance()->Fill(currentEvent->GetHCofThisEvent(),
                                           currentEvent->GetEventID());
  }
 
  G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
  if(ScM == nullptr)
    return;
  G4int nPar = ScM->GetNumberOfMesh();
  if(nPar < 1)
    return;
 
  G4HCofThisEvent* HCE = currentEvent->GetHCofThisEvent();
  if(HCE == nullptr)
    return;
  G4int nColl = HCE->GetCapacity();
  for(G4int i = 0; i < nColl; ++i)
  {
    G4VHitsCollection* HC = HCE->GetHC(i);
    if(HC != nullptr)
      ScM->Accumulate(HC);
  }
}

References G4ScoringManager::Accumulate(), G4RunManager::currentEvent, G4VScoreNtupleWriter::Fill(), G4HCofThisEvent::GetCapacity(), G4Event::GetEventID(), G4HCofThisEvent::GetHC(), G4Event::GetHCofThisEvent(), G4ScoringManager::GetNumberOfMesh(), G4ScoringManager::GetScoringManagerIfExist(), G4VScoreNtupleWriter::Instance(), and G4RunManager::isScoreNtupleWriter.

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

◆ WaitForEndEventLoopWorkers()

void G4TaskRunManager::WaitForEndEventLoopWorkers ( )

overridevirtual

Reimplemented from G4MTRunManager.

Definition at line 759 of file G4TaskRunManager.cc.

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

References PTL::ThreadPool::execute_on_all_threads(), G4RunManager::fakeRun, PTL::TaskGroup< Tp, Arg, MaxDepth >::join(), G4TaskRunManagerKernel::TerminateWorkerRunEventLoop(), threadPool, and workTaskGroup.

Referenced by RunTermination().

◆ WaitForReadyWorkers()

virtual void G4TaskRunManager::WaitForReadyWorkers ( )

inlineoverridevirtual

Reimplemented from G4MTRunManager.

Definition at line 195 of file G4TaskRunManager.hh.

195{}

Friends And Related Function Documentation

◆ G4RunManagerFactory

friend class G4RunManagerFactory

friend

Definition at line 70 of file G4TaskRunManager.hh.

Field Documentation

◆ beginOfEventLoopBarrier

G4MTBarrier G4MTRunManager::beginOfEventLoopBarrier

protectedinherited

Definition at line 274 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::ThisWorkerReady(), G4MTRunManager::WaitForEndEventLoopWorkers(), and G4MTRunManager::WaitForReadyWorkers().

◆ currentEvent

G4Event* G4RunManager::currentEvent = nullptr

protectedinherited

Definition at line 631 of file G4RunManager.hh.

Referenced by G4RunManager::AbortEvent(), G4RunManager::AbortRun(), G4RunManager::GetCurrentEvent(), G4RunManager::ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), G4WorkerTaskRunManager::ProcessOneEvent(), G4RunManager::rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4RunManager::TerminateOneEvent(), and G4RunManager::UpdateScoring().

◆ currentRun

G4Run* G4RunManager::currentRun = nullptr

protectedinherited

Definition at line 630 of file G4RunManager.hh.

Referenced by G4RunManager::AnalyzeEvent(), G4WorkerTaskRunManager::DoCleanup(), G4RunManager::GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), G4RunManager::GetCurrentRun(), G4RunManager::GetNonConstCurrentRun(), G4WorkerRunManager::MergePartialResults(), G4MTRunManager::MergeRun(), MergeRun(), G4RunManager::rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4MTRunManager::rndmSaveThisRun(), G4RunManager::rndmSaveThisRun(), G4WorkerRunManager::rndmSaveThisRun(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4RunManager::RunTermination(), G4WorkerTaskRunManager::RunTermination(), G4RunManager::StackPreviousEvent(), and G4RunManager::~G4RunManager().

◆ currentWorld

G4VPhysicalVolume* G4RunManager::currentWorld = nullptr

protectedinherited

Definition at line 643 of file G4RunManager.hh.

◆ DCtable

G4DCtable* G4RunManager::DCtable = nullptr

protectedinherited

Definition at line 628 of file G4RunManager.hh.

Referenced by G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and G4RunManager::SetDCtable().

◆ endOfEventLoopBarrier

G4MTBarrier G4MTRunManager::endOfEventLoopBarrier

protectedinherited

Definition at line 275 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::ThisWorkerEndEventLoop(), G4MTRunManager::WaitForEndEventLoopWorkers(), and G4MTRunManager::WaitForReadyWorkers().

◆ eventGrainsize

G4int G4TaskRunManager::eventGrainsize = 0

private

Definition at line 221 of file G4TaskRunManager.hh.

Referenced by ComputeNumberOfTasks(), GetGrainsize(), and SetGrainsize().

◆ eventManager

G4EventManager* G4RunManager::eventManager = nullptr

protectedinherited

Definition at line 604 of file G4RunManager.hh.

Referenced by G4RunManager::AbortEvent(), G4RunManager::AbortRun(), G4RunManager::G4RunManager(), G4RunManager::ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), G4WorkerTaskRunManager::ProcessOneEvent(), G4RunManager::SetNumberOfAdditionalWaitingStacks(), G4RunManager::SetUserAction(), and G4RunManager::StoreRandomNumberStatusToG4Event().

◆ eventModulo

G4int G4MTRunManager::eventModulo = 1

protectedinherited

Definition at line 249 of file G4MTRunManager.hh.

Referenced by ComputeNumberOfTasks(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4MTRunManager::RefillSeeds(), RefillSeeds(), G4MTRunManager::SetUpNEvents(), and SetUpNEvents().

◆ eventModuloDef

G4int G4MTRunManager::eventModuloDef = 0

protectedinherited

Definition at line 248 of file G4MTRunManager.hh.

Referenced by ComputeNumberOfTasks(), G4MTRunManager::GetEventModulo(), G4MTRunManager::InitializeEventLoop(), and G4MTRunManager::SetEventModulo().

◆ fakeRun

G4bool G4RunManager::fakeRun = false

protectedinherited

Definition at line 651 of file G4RunManager.hh.

Referenced by G4RunManager::BeamOn(), ComputeNumberOfTasks(), CreateAndStartWorkers(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4RunManager::RunTermination(), G4WorkerRunManager::RunTermination(), G4WorkerTaskRunManager::RunTermination(), G4RunManager::TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), G4WorkerTaskRunManager::TerminateEventLoop(), TerminateWorkers(), and WaitForEndEventLoopWorkers().

◆ fGeometryHasBeenDestroyed

G4bool G4RunManager::fGeometryHasBeenDestroyed = false

staticprotectedinherited

Definition at line 658 of file G4RunManager.hh.

Referenced by G4RunManager::ConstructScoringWorlds(), G4WorkerRunManager::ConstructScoringWorlds(), G4RunManager::IfGeometryHasBeenDestroyed(), G4WorkerRunManager::InitializeGeometry(), G4RunManager::ReinitializeGeometry(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), and G4RunManager::TerminateEventLoop().

◆ fMasterRM

G4MTRunManager * G4MTRunManager::fMasterRM = nullptr

staticprotectedinherited

Definition at line 243 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::G4MTRunManager(), G4TaskRunManager(), G4MTRunManager::GetMasterRunManager(), G4MTRunManager::GetMasterRunManagerKernel(), and G4MTRunManager::GetMTMasterRunManagerKernel().

◆ forcedNwokers

G4int G4MTRunManager::forcedNwokers = -1

protectedinherited

Definition at line 235 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::G4MTRunManager(), G4TaskRunManager(), G4MTRunManager::SetNumberOfThreads(), and SetNumberOfThreads().

◆ fRunManager

G4ThreadLocal G4RunManager * G4RunManager::fRunManager = nullptr

staticprivateinherited

Definition at line 663 of file G4RunManager.hh.

Referenced by G4RunManager::G4RunManager(), G4RunManager::GetRunManager(), and G4RunManager::~G4RunManager().

◆ geometryDirectlyUpdated

G4bool G4RunManager::geometryDirectlyUpdated = false

protectedinherited

Definition at line 654 of file G4RunManager.hh.

Referenced by G4RunManager::GeometryDirectlyUpdated(), and G4RunManager::InitializeGeometry().

◆ geometryInitialized

G4bool G4RunManager::geometryInitialized = false

protectedinherited

Definition at line 618 of file G4RunManager.hh.

Referenced by G4RunManager::ConfirmBeamOnCondition(), G4RunManager::Initialize(), G4RunManager::InitializeGeometry(), G4WorkerRunManager::InitializeGeometry(), and G4RunManager::ReinitializeGeometry().

◆ geometryToBeOptimized

G4bool G4RunManager::geometryToBeOptimized = true

protectedinherited

Definition at line 622 of file G4RunManager.hh.

Referenced by G4RunManager::GetGeometryToBeOptimized(), and G4RunManager::SetGeometryToBeOptimized().

◆ initializedAtLeastOnce

G4bool G4RunManager::initializedAtLeastOnce = false

protectedinherited

Definition at line 621 of file G4RunManager.hh.

Referenced by G4RunManager::ConfirmBeamOnCondition(), and G4RunManager::Initialize().

◆ initSeedsCallback

InitializeSeedsCallback G4TaskRunManager::initSeedsCallback

protected

Initial value:

= [](G4int, G4int&, G4int&) {
    return false;
  }

Definition at line 238 of file G4TaskRunManager.hh.

Referenced by InitializeEventLoop(), and SetInitializeSeedsCallback().

◆ isScoreNtupleWriter

G4bool G4RunManager::isScoreNtupleWriter = false

protectedinherited

Definition at line 652 of file G4RunManager.hh.

Referenced by G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4RunManager::RunTermination(), and G4RunManager::UpdateScoring().

◆ kernel

G4RunManagerKernel* G4RunManager::kernel = nullptr

protectedinherited

Definition at line 603 of file G4RunManager.hh.

Referenced by G4WorkerRunManager::ConstructScoringWorlds(), G4RunManagerFactory::CreateRunManager(), G4RunManager::DefineWorldVolume(), G4RunManager::DumpRegion(), G4MTRunManager::G4MTRunManager(), G4RunManager::G4RunManager(), G4TaskRunManager(), G4RunManager::GeometryHasBeenModified(), G4MTRunManager::GetMasterRunManagerKernel(), G4RunManagerFactory::GetMasterRunManagerKernel(), G4RunManager::GetVersionString(), G4WorkerRunManager::GetWorkerRunManagerKernel(), G4WorkerTaskRunManager::GetWorkerRunManagerKernel(), G4RunManager::InitializeGeometry(), G4WorkerRunManager::InitializeGeometry(), G4RunManager::InitializePhysics(), G4RunManager::PhysicsHasBeenModified(), G4RunManager::ReinitializeGeometry(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4RunManager::RunTermination(), G4RunManager::SetGeometryToBeOptimized(), G4RunManager::SetPrimaryTransformer(), G4RunManager::SetUserInitialization(), G4RunManager::SetVerboseLevel(), and G4RunManager::~G4RunManager().

◆ m_is_initialized

bool PTL::TaskRunManager::m_is_initialized = false

protectedinherited

Definition at line 87 of file TaskRunManager.hh.

Referenced by PTL::TaskRunManager::Initialize(), PTL::TaskRunManager::IsInitialized(), and PTL::TaskRunManager::Terminate().

◆ m_task_manager

TaskManager* PTL::TaskRunManager::m_task_manager = nullptr

protectedinherited

Definition at line 92 of file TaskRunManager.hh.

Referenced by PTL::TaskRunManager::GetTaskManager(), PTL::TaskRunManager::Initialize(), and PTL::TaskRunManager::Terminate().

◆ m_task_queue

VUserTaskQueue* PTL::TaskRunManager::m_task_queue = nullptr

protectedinherited

Definition at line 90 of file TaskRunManager.hh.

Referenced by PTL::TaskRunManager::Initialize().

◆ m_thread_pool

ThreadPool* PTL::TaskRunManager::m_thread_pool = nullptr

protectedinherited

Definition at line 91 of file TaskRunManager.hh.

Referenced by PTL::TaskRunManager::GetNumberActiveThreads(), PTL::TaskRunManager::GetNumberOfThreads(), PTL::TaskRunManager::GetThreadPool(), PTL::TaskRunManager::Initialize(), and PTL::TaskRunManager::Terminate().

◆ m_verbose

int PTL::TaskRunManager::m_verbose = 0

protectedinherited

Definition at line 88 of file TaskRunManager.hh.

Referenced by PTL::TaskRunManager::GetVerbose(), PTL::TaskRunManager::Initialize(), and PTL::TaskRunManager::SetVerbose().

◆ m_workers

uint64_t PTL::TaskRunManager::m_workers = 0

protectedinherited

Definition at line 89 of file TaskRunManager.hh.

Referenced by PTL::TaskRunManager::Initialize(), and PTL::TaskRunManager::TaskRunManager().

◆ masterRNGEngine

CLHEP::HepRandomEngine* G4TaskRunManager::masterRNGEngine = nullptr

private

Definition at line 224 of file G4TaskRunManager.hh.

Referenced by G4TaskRunManager(), InitializeEventLoop(), and RefillSeeds().

◆ masterRunProfiler

std::unique_ptr<ProfilerConfig> G4RunManager::masterRunProfiler

privateinherited

Definition at line 668 of file G4RunManager.hh.

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

◆ masterScM

G4ScoringManager * G4MTRunManager::masterScM = nullptr

staticprotectedinherited

Definition at line 240 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::ConstructScoringWorlds(), ConstructScoringWorlds(), G4MTRunManager::G4MTRunManager(), G4TaskRunManager(), G4MTRunManager::GetMasterScoringManager(), G4MTRunManager::MergeScores(), and MergeScores().

◆ masterThreadId

G4ThreadId G4MTRunManager::masterThreadId = G4ThisThread::get_id()

staticprotectedinherited

Definition at line 256 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::G4MTRunManager(), and G4MTRunManager::GetMasterThreadId().

◆ masterWorlds

G4MTRunManager::masterWorlds_t G4MTRunManager::masterWorlds = G4MTRunManager::masterWorlds_t()

staticprotectedinherited

Definition at line 242 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::addWorld(), G4MTRunManager::ConstructScoringWorlds(), ConstructScoringWorlds(), and G4MTRunManager::GetMasterWorlds().

◆ msgText

G4String G4RunManager::msgText = " "

protectedinherited

Definition at line 647 of file G4RunManager.hh.

Referenced by G4MTRunManager::InitializeEventLoop(), G4RunManager::InitializeEventLoop(), InitializeEventLoop(), G4RunManager::ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), and G4WorkerTaskRunManager::ProcessOneEvent().

◆ MTkernel

G4TaskRunManagerKernel* G4TaskRunManager::MTkernel = nullptr

private

Definition at line 226 of file G4TaskRunManager.hh.

Referenced by AbortRun(), G4TaskRunManager(), GetMTMasterRunManagerKernel(), and InitializeEventLoop().

◆ n_perviousEventsToBeStored

G4int G4RunManager::n_perviousEventsToBeStored = 0

protectedinherited

Definition at line 633 of file G4RunManager.hh.

Referenced by G4RunManager::GetPreviousEvent(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4RunManager::SetNumberOfEventsToBeStored(), and G4RunManager::StackPreviousEvent().

◆ n_select_msg

G4int G4RunManager::n_select_msg = -1

protectedinherited

Definition at line 648 of file G4RunManager.hh.

Referenced by G4RunManager::GetNumberOfSelectEvents(), G4MTRunManager::InitializeEventLoop(), G4RunManager::InitializeEventLoop(), InitializeEventLoop(), G4RunManager::ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), and G4WorkerTaskRunManager::ProcessOneEvent().

◆ nextActionRequest

WorkerActionRequest G4MTRunManager::nextActionRequest = WorkerActionRequest::UNDEFINED

protectedinherited

Definition at line 246 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::NewActionRequest(), and G4MTRunManager::ThisWorkerWaitForNextAction().

◆ nextActionRequestBarrier

G4MTBarrier G4MTRunManager::nextActionRequestBarrier

protectedinherited

Definition at line 276 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::NewActionRequest(), and G4MTRunManager::ThisWorkerWaitForNextAction().

◆ nParallelWorlds

G4int G4RunManager::nParallelWorlds = 0

protectedinherited

Definition at line 645 of file G4RunManager.hh.

Referenced by G4RunManager::GetNumberOfParallelWorld(), and G4RunManager::InitializeGeometry().

◆ nSeedsFilled

G4int G4MTRunManager::nSeedsFilled = 0

protectedinherited

Definition at line 251 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4MTRunManager::RefillSeeds(), RefillSeeds(), SetUpAnEvent(), G4MTRunManager::SetUpAnEvent(), G4MTRunManager::SetUpNEvents(), and SetUpNEvents().

◆ nSeedsMax

G4int G4MTRunManager::nSeedsMax = 10000

protectedinherited

Definition at line 252 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::G4MTRunManager(), G4TaskRunManager(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4MTRunManager::RefillSeeds(), and RefillSeeds().

◆ nSeedsPerEvent

G4int G4MTRunManager::nSeedsPerEvent = 2

protectedinherited

Definition at line 253 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::G4MTRunManager(), G4TaskRunManager(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4MTRunManager::RefillSeeds(), RefillSeeds(), SetUpAnEvent(), G4MTRunManager::SetUpAnEvent(), G4MTRunManager::SetUpNEvents(), and SetUpNEvents().

◆ nSeedsUsed

G4int G4MTRunManager::nSeedsUsed = 0

protectedinherited

Definition at line 250 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), SetUpAnEvent(), G4MTRunManager::SetUpAnEvent(), G4MTRunManager::SetUpNEvents(), and SetUpNEvents().

◆ numberOfEventProcessed

G4int G4RunManager::numberOfEventProcessed = 0

protectedinherited

Definition at line 649 of file G4RunManager.hh.

Referenced by G4RunManager::BeamOn(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), SetUpAnEvent(), G4MTRunManager::SetUpAnEvent(), G4MTRunManager::SetUpNEvents(), SetUpNEvents(), G4RunManager::TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), G4WorkerTaskRunManager::TerminateEventLoop(), and G4RunManager::TerminateOneEvent().

◆ numberOfEventsPerTask

G4int G4TaskRunManager::numberOfEventsPerTask = -1

private

Definition at line 222 of file G4TaskRunManager.hh.

Referenced by ComputeNumberOfTasks(), CreateAndStartWorkers(), GetNumberOfEventsPerTask(), and SetUpNEvents().

◆ numberOfEventToBeProcessed

G4int G4MTRunManager::numberOfEventToBeProcessed = 0

protectedinherited

Definition at line 238 of file G4MTRunManager.hh.

Referenced by ComputeNumberOfTasks(), CreateAndStartWorkers(), G4TaskRunManager(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4MTRunManager::RefillSeeds(), RefillSeeds(), SetUpAnEvent(), G4MTRunManager::SetUpAnEvent(), G4MTRunManager::SetUpNEvents(), and SetUpNEvents().

◆ numberOfTasks

G4int G4TaskRunManager::numberOfTasks = -1

private

Definition at line 223 of file G4TaskRunManager.hh.

Referenced by ComputeNumberOfTasks(), CreateAndStartWorkers(), GetNumberOfTasks(), InitializeEventLoop(), and RefillSeeds().

◆ nworkers

G4int G4MTRunManager::nworkers = 2

protectedinherited

Definition at line 232 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::CreateAndStartWorkers(), G4MTRunManager::G4MTRunManager(), G4TaskRunManager(), G4MTRunManager::GetNumberOfThreads(), G4MTRunManager::InitializeEventLoop(), InitializeThreadPool(), G4MTRunManager::RefillSeeds(), G4MTRunManager::SetNumberOfThreads(), and SetNumberOfThreads().

◆ physicsInitialized

G4bool G4RunManager::physicsInitialized = false

protectedinherited

Definition at line 619 of file G4RunManager.hh.

Referenced by G4RunManager::ConfirmBeamOnCondition(), G4RunManager::Initialize(), and G4RunManager::InitializePhysics().

◆ physicsList

G4VUserPhysicsList* G4RunManager::physicsList = nullptr

protectedinherited

Definition at line 607 of file G4RunManager.hh.

Referenced by G4RunManager::DeleteUserInitializations(), G4RunManager::GetUserPhysicsList(), G4RunManager::InitializePhysics(), G4RunManager::SetUserInitialization(), and G4WorkerRunManager::~G4WorkerRunManager().

◆ pinAffinity

G4int G4MTRunManager::pinAffinity = 0

privateinherited

Definition at line 284 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::GetPinAffinity(), and G4MTRunManager::SetPinAffinity().

◆ poolInitialized

G4bool& G4TaskRunManager::poolInitialized = PTL::TaskRunManager::m_is_initialized

protected

Definition at line 233 of file G4TaskRunManager.hh.

Referenced by InitializeThreadPool(), SetNumberOfThreads(), and ThreadPoolIsInitialized().

◆ previousEvents

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

protectedinherited

Definition at line 632 of file G4RunManager.hh.

Referenced by G4RunManager::CleanUpPreviousEvents(), G4RunManager::CleanUpUnnecessaryEvents(), G4RunManager::G4RunManager(), G4RunManager::GetPreviousEvent(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4RunManager::StackPreviousEvent(), and G4RunManager::~G4RunManager().

◆ printModulo

G4int G4RunManager::printModulo = -1

protectedinherited

Definition at line 626 of file G4RunManager.hh.

Referenced by G4RunManager::GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), G4RunManager::GetPrintProgress(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and G4RunManager::SetPrintProgress().

◆ processUIBarrier

G4MTBarrier G4MTRunManager::processUIBarrier

protectedinherited

Definition at line 277 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::RequestWorkersProcessCommandsStack(), and G4MTRunManager::ThisWorkerProcessCommandsStackDone().

◆ randDbl

G4double* G4MTRunManager::randDbl = nullptr

protectedinherited

Definition at line 254 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::G4MTRunManager(), G4TaskRunManager(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4MTRunManager::RefillSeeds(), RefillSeeds(), and G4MTRunManager::~G4MTRunManager().

◆ randomNumberStatusDir

G4String G4RunManager::randomNumberStatusDir = "./"

protectedinherited

Definition at line 638 of file G4RunManager.hh.

Referenced by G4RunManager::G4RunManager(), G4RunManager::GetRandomNumberStoreDir(), G4RunManager::RestoreRandomNumberStatus(), G4RunManager::rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4MTRunManager::rndmSaveThisRun(), G4RunManager::rndmSaveThisRun(), G4WorkerRunManager::rndmSaveThisRun(), G4RunManager::SetRandomNumberStoreDir(), G4MTRunManager::StoreRNGStatus(), G4RunManager::StoreRNGStatus(), G4WorkerRunManager::StoreRNGStatus(), StoreRNGStatus(), and G4WorkerTaskRunManager::StoreRNGStatus().

◆ randomNumberStatusForThisEvent

G4String G4RunManager::randomNumberStatusForThisEvent = ""

protectedinherited

Definition at line 640 of file G4RunManager.hh.

Referenced by G4RunManager::G4RunManager(), G4RunManager::GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), and G4RunManager::GetRandomNumberStatusForThisEvent().

◆ randomNumberStatusForThisRun

G4String G4RunManager::randomNumberStatusForThisRun = ""

protectedinherited

Definition at line 639 of file G4RunManager.hh.

Referenced by G4RunManager::G4RunManager(), G4RunManager::GetRandomNumberStatusForThisRun(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), and G4WorkerTaskRunManager::RunInitialization().

◆ rngStatusEventsFlag

G4bool G4RunManager::rngStatusEventsFlag = false

protectedinherited

Definition at line 641 of file G4RunManager.hh.

Referenced by G4RunManager::GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), G4RunManager::GetRandomNumberStorePerEvent(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and G4RunManager::SetRandomNumberStorePerEvent().

◆ runAborted

G4bool G4RunManager::runAborted = false

protectedinherited

Definition at line 620 of file G4RunManager.hh.

Referenced by G4MTRunManager::AbortRun(), G4RunManager::AbortRun(), AbortRun(), G4WorkerRunManager::DoEventLoop(), G4RunManager::DoEventLoop(), G4WorkerTaskRunManager::DoEventLoop(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4MTRunManager::SetUpNEvents(), SetUpNEvents(), G4RunManager::TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), and G4WorkerTaskRunManager::TerminateEventLoop().

◆ runIDCounter

G4int G4RunManager::runIDCounter = 0

protectedinherited

Definition at line 624 of file G4RunManager.hh.

Referenced by G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4RunManager::RunTermination(), and G4RunManager::SetRunIDCounter().

◆ runManagerType

RMType G4RunManager::runManagerType

protectedinherited

Definition at line 656 of file G4RunManager.hh.

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

◆ runMessenger

G4RunMessenger* G4RunManager::runMessenger = nullptr

privateinherited

Definition at line 666 of file G4RunManager.hh.

Referenced by G4RunManager::G4RunManager(), and G4RunManager::~G4RunManager().

◆ seedOncePerCommunication

G4int G4MTRunManager::seedOncePerCommunication = 0

staticprotectedinherited

Definition at line 257 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::InitializeEventLoop(), G4MTRunManager::RefillSeeds(), G4MTRunManager::SeedOncePerCommunication(), G4MTRunManager::SetSeedOncePerCommunication(), and G4MTRunManager::SetUpNEvents().

◆ selectMacro

G4String G4RunManager::selectMacro = ""

protectedinherited

Definition at line 650 of file G4RunManager.hh.

Referenced by G4RunManager::GetSelectMacro(), G4MTRunManager::InitializeEventLoop(), G4RunManager::InitializeEventLoop(), and InitializeEventLoop().

◆ storeRandomNumberStatus

G4bool G4RunManager::storeRandomNumberStatus = false

protectedinherited

Definition at line 636 of file G4RunManager.hh.

Referenced by G4RunManager::GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), G4RunManager::GetRandomNumberStore(), G4RunManager::rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4MTRunManager::rndmSaveThisRun(), G4RunManager::rndmSaveThisRun(), G4WorkerRunManager::rndmSaveThisRun(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), and G4RunManager::SetRandomNumberStore().

◆ storeRandomNumberStatusToG4Event

G4int G4RunManager::storeRandomNumberStatusToG4Event = 0

protectedinherited

Definition at line 637 of file G4RunManager.hh.

Referenced by G4RunManager::GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), G4RunManager::GetFlagRandomNumberStatusToG4Event(), G4RunManager::GetRandomNumberStatusForThisEvent(), and G4RunManager::StoreRandomNumberStatusToG4Event().

◆ taskManager

G4TaskManager*& G4TaskRunManager::taskManager = PTL::TaskRunManager::m_task_manager

protected

Definition at line 236 of file G4TaskRunManager.hh.

◆ taskQueue

G4VUserTaskQueue*& G4TaskRunManager::taskQueue = PTL::TaskRunManager::m_task_queue

protected

Definition at line 235 of file G4TaskRunManager.hh.

Referenced by G4TaskRunManager().

◆ threadPool

G4ThreadPool*& G4TaskRunManager::threadPool = PTL::TaskRunManager::m_thread_pool

protected

Definition at line 234 of file G4TaskRunManager.hh.

Referenced by ComputeNumberOfTasks(), CreateAndStartWorkers(), Initialize(), InitializeThreadPool(), RequestWorkersProcessCommandsStack(), TerminateWorkers(), WaitForEndEventLoopWorkers(), and ~G4TaskRunManager().

◆ threads

G4ThreadsList G4MTRunManager::threads

privateinherited

Definition at line 286 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::CreateAndStartWorkers(), G4MTRunManager::GetNumberActiveThreads(), G4MTRunManager::SetNumberOfThreads(), and G4MTRunManager::TerminateWorkers().

◆ timer

G4Timer* G4RunManager::timer = nullptr

protectedinherited

Definition at line 627 of file G4RunManager.hh.

Referenced by G4RunManager::G4RunManager(), G4MTRunManager::InitializeEventLoop(), G4RunManager::InitializeEventLoop(), InitializeEventLoop(), G4RunManager::TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), G4WorkerTaskRunManager::TerminateEventLoop(), and G4RunManager::~G4RunManager().

◆ uiCmdsForWorkers

std::vector<G4String> G4MTRunManager::uiCmdsForWorkers

privateinherited

Definition at line 289 of file G4MTRunManager.hh.

Referenced by G4MTRunManager::GetCommandStack(), and G4MTRunManager::PrepareCommandsStack().

◆ userActionInitialization

G4VUserActionInitialization* G4RunManager::userActionInitialization = nullptr

protectedinherited

Definition at line 608 of file G4RunManager.hh.

Referenced by G4RunManager::DeleteUserInitializations(), G4RunManager::GetNonConstUserActionInitialization(), G4RunManager::GetUserActionInitialization(), G4MTRunManager::SetUserInitialization(), G4RunManager::SetUserInitialization(), and G4WorkerRunManager::~G4WorkerRunManager().

◆ userDetector

G4VUserDetectorConstruction* G4RunManager::userDetector = nullptr

protectedinherited

Definition at line 606 of file G4RunManager.hh.

Referenced by G4RunManager::DeleteUserInitializations(), G4RunManager::GetUserDetectorConstruction(), G4RunManager::InitializeGeometry(), G4WorkerRunManager::InitializeGeometry(), G4RunManager::SetUserInitialization(), and G4WorkerRunManager::~G4WorkerRunManager().

◆ userEventAction

G4UserEventAction* G4RunManager::userEventAction = nullptr

protectedinherited

Definition at line 613 of file G4RunManager.hh.

Referenced by G4RunManager::GetUserEventAction(), and G4RunManager::SetUserAction().

◆ userPrimaryGeneratorAction

G4VUserPrimaryGeneratorAction* G4RunManager::userPrimaryGeneratorAction = nullptr

protectedinherited

Definition at line 612 of file G4RunManager.hh.

Referenced by G4WorkerRunManager::DoEventLoop(), G4WorkerTaskRunManager::DoEventLoop(), G4RunManager::GenerateEvent(), G4WorkerRunManager::GenerateEvent(), G4WorkerTaskRunManager::GenerateEvent(), G4RunManager::GetUserPrimaryGeneratorAction(), G4RunManager::SetUserAction(), and G4RunManager::~G4RunManager().

◆ userRunAction

G4UserRunAction* G4RunManager::userRunAction = nullptr

protectedinherited

Definition at line 611 of file G4RunManager.hh.

Referenced by G4RunManager::GetUserRunAction(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), G4RunManager::RunTermination(), G4RunManager::SetUserAction(), and G4RunManager::~G4RunManager().

◆ userStackingAction

G4UserStackingAction* G4RunManager::userStackingAction = nullptr

protectedinherited

Definition at line 614 of file G4RunManager.hh.

Referenced by G4RunManager::GetUserStackingAction(), and G4RunManager::SetUserAction().

◆ userSteppingAction

G4UserSteppingAction* G4RunManager::userSteppingAction = nullptr

protectedinherited

Definition at line 616 of file G4RunManager.hh.

Referenced by G4RunManager::GetUserSteppingAction(), and G4RunManager::SetUserAction().

◆ userTrackingAction

G4UserTrackingAction* G4RunManager::userTrackingAction = nullptr

protectedinherited

Definition at line 615 of file G4RunManager.hh.

Referenced by G4RunManager::GetUserTrackingAction(), and G4RunManager::SetUserAction().

◆ userWorkerInitialization

G4UserWorkerInitialization* G4RunManager::userWorkerInitialization = nullptr

protectedinherited

Definition at line 609 of file G4RunManager.hh.

Referenced by G4RunManager::DeleteUserInitializations(), G4RunManager::GetUserWorkerInitialization(), G4MTRunManager::SetUserInitialization(), and G4WorkerRunManager::~G4WorkerRunManager().

◆ userWorkerThreadInitialization

G4UserWorkerThreadInitialization* G4RunManager::userWorkerThreadInitialization = nullptr

protectedinherited

Definition at line 610 of file G4RunManager.hh.

Referenced by G4MTRunManager::CreateAndStartWorkers(), G4RunManager::DeleteUserInitializations(), G4RunManager::GetUserWorkerThreadInitialization(), G4MTRunManager::InitializeEventLoop(), InitializeEventLoop(), G4MTRunManager::SetUserInitialization(), G4MTRunManager::TerminateWorkers(), and G4WorkerRunManager::~G4WorkerRunManager().

◆ verboseLevel

G4int G4RunManager::verboseLevel = 0

protectedinherited

Definition at line 625 of file G4RunManager.hh.

Referenced by AddEventTask(), ComputeNumberOfTasks(), G4RunManager::ConfirmBeamOnCondition(), G4MTRunManager::CreateAndStartWorkers(), G4RunManager::DeleteUserInitializations(), G4MTRunManager::G4MTRunManager(), G4RunManager::GetVerboseLevel(), G4MTRunManager::InitializeEventLoop(), G4RunManager::InitializeEventLoop(), InitializeEventLoop(), G4RunManager::InitializeGeometry(), InitializeThreadPool(), G4RunManager::ReinitializeGeometry(), G4RunManager::ReOptimize(), G4RunManager::RestoreRandomNumberStatus(), G4RunManager::rndmSaveThisEvent(), G4WorkerRunManager::rndmSaveThisEvent(), G4MTRunManager::rndmSaveThisRun(), G4RunManager::rndmSaveThisRun(), G4WorkerRunManager::rndmSaveThisRun(), G4RunManager::RunInitialization(), G4WorkerRunManager::RunInitialization(), G4WorkerTaskRunManager::RunInitialization(), SetNumberOfThreads(), G4RunManager::SetVerboseLevel(), G4RunManager::TerminateEventLoop(), G4WorkerRunManager::TerminateEventLoop(), G4WorkerTaskRunManager::TerminateEventLoop(), G4RunManager::~G4RunManager(), and G4WorkerRunManager::~G4WorkerRunManager().

◆ workersStarted

bool G4TaskRunManager::workersStarted = false

private

Definition at line 220 of file G4TaskRunManager.hh.

◆ workTaskGroup

RunTaskGroup* G4TaskRunManager::workTaskGroup = nullptr

protected

Definition at line 230 of file G4TaskRunManager.hh.

Referenced by AddEventTask(), CreateAndStartWorkers(), InitializeThreadPool(), TerminateWorkers(), WaitForEndEventLoopWorkers(), and ~G4TaskRunManager().

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

source/tasking/include/G4TaskRunManager.hh
source/tasking/src/G4TaskRunManager.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ G4ThreadsList

◆ InitializeSeedsCallback

◆ masterWorlds_t

◆ pointer

◆ ProfilerConfig

◆ RunTaskGroup

Member Enumeration Documentation

◆ RMType

◆ WorkerActionRequest

Constructor & Destructor Documentation

◆ G4TaskRunManager() [1/2]

◆ G4TaskRunManager() [2/2]

◆ ~G4TaskRunManager()

Member Function Documentation

◆ AbortEvent()

◆ AbortRun()

◆ AddEventTask()

◆ addWorld()

◆ AnalyzeEvent()

◆ BeamOn()

◆ CleanUpPreviousEvents()

◆ CleanUpUnnecessaryEvents()

◆ ComputeNumberOfTasks()

◆ ConfigureProfilers() [1/2]

◆ ConfigureProfilers() [2/2]

◆ ConfirmBeamOnCondition()

◆ ConstructScoringWorlds()

◆ CreateAndStartWorkers()

◆ CutOffHasBeenModified()

◆ DefineWorldVolume()

◆ DeleteUserInitializations()

◆ DoEventLoop()

◆ DumpRegion() [1/2]

◆ DumpRegion() [2/2]

◆ GenerateEvent()

◆ GeometryDirectlyUpdated()

◆ GeometryHasBeenModified()

◆ GetCommandStack()

◆ GetCurrentEvent()

◆ GetCurrentRun()

◆ GetEventModulo()

◆ GetFlagRandomNumberStatusToG4Event()

◆ GetGeometryToBeOptimized()

◆ GetGrainsize()

◆ GetInstance()

◆ getMasterRandomEngine()

◆ GetMasterRunManager() [1/2]

◆ GetMasterRunManager() [2/2]

◆ GetMasterRunManagerKernel()

◆ GetMasterScoringManager()

◆ GetMasterTheadId()

◆ GetMasterThreadId()

◆ GetMasterWorlds()

◆ GetMTMasterRunManagerKernel()

◆ GetNonConstCurrentRun()

◆ GetNonConstUserActionInitialization()

◆ GetNumberActiveThreads()

◆ GetNumberOfEventsPerTask()

◆ GetNumberOfEventsToBeProcessed()

◆ GetNumberOfParallelWorld()

◆ GetNumberOfSelectEvents()

◆ GetNumberOfTasks()

◆ GetNumberOfThreads()

◆ GetPinAffinity()

◆ GetPreviousEvent()

◆ GetPrintProgress()

◆ GetPrivateMasterRunManager()