G4WorkerRunManager Class Reference

#include <G4WorkerRunManager.hh>

Inheritance diagram for G4WorkerRunManager:

Collaboration diagram for G4WorkerRunManager:

Public Member Functions
	G4WorkerRunManager ()
	~G4WorkerRunManager ()
virtual void	InitializeGeometry ()
virtual void	RunInitialization ()
virtual void	DoEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)
virtual void	ProcessOneEvent (G4int i_event)
virtual G4Event *	GenerateEvent (G4int i_event)
virtual void	RunTermination ()
virtual void	TerminateEventLoop ()
virtual void	DoWork ()
void	SetWorkerThread (G4WorkerThread *wc)
	Sets the worker context. More...
virtual void	SetUserInitialization (G4VUserPhysicsList *userInit)
virtual void	SetUserInitialization (G4VUserDetectorConstruction *userInit)
virtual void	SetUserInitialization (G4VUserActionInitialization *userInit)
virtual void	SetUserInitialization (G4UserWorkerInitialization *userInit)
virtual void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit)
virtual void	SetUserAction (G4UserRunAction *userAction)
virtual void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction)
virtual void	SetUserAction (G4UserEventAction *userAction)
virtual void	SetUserAction (G4UserStackingAction *userAction)
virtual void	SetUserAction (G4UserTrackingAction *userAction)
virtual void	SetUserAction (G4UserSteppingAction *userAction)
virtual void	RestoreRndmEachEvent (G4bool flag)
Public Member Functions inherited from G4RunManager
	G4RunManager ()
virtual	~G4RunManager ()
virtual void	BeamOn (G4int n_event, const char *macroFile=0, G4int n_select=-1)
virtual void	Initialize ()
virtual void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)
virtual void	AbortRun (G4bool softAbort=false)
virtual void	AbortEvent ()
virtual void	InitializePhysics ()
virtual G4bool	ConfirmBeamOnCondition ()
virtual void	InitializeEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)
virtual void	TerminateOneEvent ()
virtual void	AnalyzeEvent (G4Event *anEvent)
void	DumpRegion (const G4String &rname) const
void	DumpRegion (G4Region *region=0) const
virtual void	rndmSaveThisRun ()
virtual void	rndmSaveThisEvent ()
virtual void	RestoreRandomNumberStatus (const G4String &fileN)
const G4VUserDetectorConstruction *	GetUserDetectorConstruction () const
const G4VUserPhysicsList *	GetUserPhysicsList () const
const G4VUserActionInitialization *	GetUserActionInitialization () const
G4VUserActionInitialization *	GetNonConstUserActionInitialization () const
const G4UserWorkerInitialization *	GetUserWorkerInitialization () const
const G4UserWorkerThreadInitialization *	GetUserWorkerThreadInitialization () const
const G4UserRunAction *	GetUserRunAction () const
const G4VUserPrimaryGeneratorAction *	GetUserPrimaryGeneratorAction () const
const G4UserEventAction *	GetUserEventAction () const
const G4UserStackingAction *	GetUserStackingAction () const
const G4UserTrackingAction *	GetUserTrackingAction () const
const G4UserSteppingAction *	GetUserSteppingAction () const
void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)
const G4String &	GetVersionString () const
void	SetPrimaryTransformer (G4PrimaryTransformer *pt)
void	StoreRandomNumberStatusToG4Event (G4int vl)
G4int	GetFlagRandomNumberStatusToG4Event () const
void	SetRandomNumberStore (G4bool flag)
G4bool	GetRandomNumberStore () const
void	SetRandomNumberStoreDir (const G4String &dir)
const G4String &	GetRandomNumberStoreDir () const
const G4String &	GetRandomNumberStatusForThisRun () const
const G4String &	GetRandomNumberStatusForThisEvent () const
void	SetRandomNumberStorePerEvent (G4bool flag)
G4bool	GetRandomNumberStorePerEvent () const
void	GeometryHasBeenModified (G4bool prop=true)
void	ReinitializeGeometry (G4bool destroyFirst=false, G4bool prop=true)
void	PhysicsHasBeenModified ()
void	CutOffHasBeenModified ()
void	ReOptimizeMotherOf (G4VPhysicalVolume *)
void	ReOptimize (G4LogicalVolume *)
void	SetVerboseLevel (G4int vl)
G4int	GetVerboseLevel () const
G4int	GetPrintProgress ()
void	SetPrintProgress (G4int i)
void	SetGeometryToBeOptimized (G4bool vl)
G4bool	GetGeometryToBeOptimized ()
void	SetNumberOfEventsToBeStored (G4int val)
const G4Run *	GetCurrentRun () const
G4Run *	GetNonConstCurrentRun () const
const G4Event *	GetCurrentEvent () const
const G4Event *	GetPreviousEvent (G4int i) const
void	SetRunIDCounter (G4int i)
G4int	GetNumberOfParallelWorld () const
void	SetNumberOfEventsToBeProcessed (G4int val)
G4int	GetNumberOfEventsToBeProcessed () const
G4int	GetNumberOfSelectEvents () const
G4String	GetSelectMacro () const
void	SetDCtable (G4DCtable *DCtbl)
RMType	GetRunManagerType () const

Static Public Member Functions
static G4WorkerRunManager *	GetWorkerRunManager ()
static G4WorkerRunManagerKernel *	GetWorkerRunManagerKernel ()
Static Public Member Functions inherited from G4RunManager
static G4RunManager *	GetRunManager ()
static G4bool	IfGeometryHasBeenDestroyed ()

Protected Member Functions
virtual void	ConstructScoringWorlds ()
virtual void	StoreRNGStatus (const G4String &filenamePrefix)
virtual void	MergePartialResults ()
Protected Member Functions inherited from G4RunManager
void	CleanUpPreviousEvents ()
void	CleanUpUnnecessaryEvents (G4int keepNEvents)
void	StackPreviousEvent (G4Event *anEvent)
	G4RunManager (RMType rmType)
void	UpdateScoring ()
virtual void	DeleteUserInitializations ()

Protected Attributes
G4bool	eventLoopOnGoing
G4bool	runIsSeeded
G4int	nevModulo
G4int	currEvID
G4SeedsQueue	seedsQueue
G4bool	readStatusFromFile
Protected Attributes inherited from G4RunManager
G4RunManagerKernel *	kernel
G4EventManager *	eventManager
G4VUserDetectorConstruction *	userDetector
G4VUserPhysicsList *	physicsList
G4VUserActionInitialization *	userActionInitialization
G4UserWorkerInitialization *	userWorkerInitialization
G4UserWorkerThreadInitialization *	userWorkerThreadInitialization
G4UserRunAction *	userRunAction
G4VUserPrimaryGeneratorAction *	userPrimaryGeneratorAction
G4UserEventAction *	userEventAction
G4UserStackingAction *	userStackingAction
G4UserTrackingAction *	userTrackingAction
G4UserSteppingAction *	userSteppingAction
G4bool	geometryInitialized
G4bool	physicsInitialized
G4bool	runAborted
G4bool	initializedAtLeastOnce
G4bool	geometryToBeOptimized
G4int	runIDCounter
G4int	verboseLevel
G4int	printModulo
G4Timer *	timer
G4DCtable *	DCtable
G4Run *	currentRun
G4Event *	currentEvent
std::list< G4Event * > *	previousEvents
G4int	n_perviousEventsToBeStored
G4int	numberOfEventToBeProcessed
G4bool	storeRandomNumberStatus
G4int	storeRandomNumberStatusToG4Event
G4String	randomNumberStatusDir
G4String	randomNumberStatusForThisRun
G4String	randomNumberStatusForThisEvent
G4bool	rngStatusEventsFlag
G4VPhysicalVolume *	currentWorld
G4int	nParallelWorlds
G4String	msgText
G4int	n_select_msg
G4int	numberOfEventProcessed
G4String	selectMacro
G4bool	fakeRun
RMType	runManagerType

Additional Inherited Members
Public Types inherited from G4RunManager
enum	RMType { sequentialRM, masterRM, workerRM }
Static Protected Attributes inherited from G4RunManager
static G4bool	fGeometryHasBeenDestroyed = false

Detailed Description

Definition at line 47 of file G4WorkerRunManager.hh.

Constructor & Destructor Documentation

G4WorkerRunManager::G4WorkerRunManager

(

)

Definition at line 58 of file G4WorkerRunManager.cc.

                                       : G4RunManager(workerRM) {
    //This constructor should never be called in non-multithreaded mode
#ifndef G4MULTITHREADED
    G4ExceptionDescription msg;
    msg<<"Geant4 code is compiled without multi-threading support (-DG4MULTITHREADED is set to off).";
    msg<<" This type of RunManager can only be used in mult-threaded applications.";
    G4Exception("G4WorkerRunManager::G4WorkerRunManager()","Run0103",FatalException,msg);
#endif
    G4ParticleTable::GetParticleTable()->WorkerG4ParticleTable();
    G4ScoringManager* masterScM = G4MTRunManager::GetMasterScoringManager();
    if(masterScM) G4ScoringManager::GetScoringManager(); //TLS instance for a worker

    eventLoopOnGoing = false;
    runIsSeeded = false;
    nevModulo = -1;
    currEvID = -1;
    workerContext = 0;
    readStatusFromFile = false;

    G4UImanager::GetUIpointer()->SetIgnoreCmdNotFound(true);

#ifdef G4MULTITHREADED
    G4VVisManager* pVVis = G4VVisManager::GetConcreteInstance();
    if(pVVis)
    {
      pVVis->SetUpForAThread();
      visIsSetUp = true;
    }
    else
    { visIsSetUp = false; }
#endif
}

Here is the call graph for this function:

G4WorkerRunManager::~G4WorkerRunManager

(

)

Definition at line 93 of file G4WorkerRunManager.cc.

                                        {
    // Delete thread-local process manager objects
    physicsList->RemoveProcessManager();

    //Put these pointers to zero: owned by master thread
    //If not to zero, the base class destructor will attempt to
    //delete them
    userDetector = 0;
    userWorkerInitialization = 0;
    userWorkerThreadInitialization = 0;
    userActionInitialization = 0;
    physicsList = 0;
    if(verboseLevel>0) G4cout<<"Destroying WorkerRunManager ("<<this<<")"<<G4endl;
}

Here is the call graph for this function:

Member Function Documentation

void G4WorkerRunManager::ConstructScoringWorlds ( )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 443 of file G4WorkerRunManager.cc.

{
    // Return if unnecessary
    G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
    if(!ScM) return;
    G4int nPar = ScM->GetNumberOfMesh();
    if(nPar<1) return;

    // Update thread-local G4TransportationManager of all the world volumes
    kernel->WorkerUpdateWorldVolume();

    G4ScoringManager* masterScM = G4MTRunManager::GetMasterScoringManager();
    assert( masterScM != NULL );
    
    G4ParticleTable::G4PTblDicIterator* particleIterator
     = G4ParticleTable::GetParticleTable()->GetIterator();
    
    for(G4int iw=0;iw<nPar;iw++)
    {
      G4VScoringMesh* mesh = ScM->GetMesh(iw);
      if(fGeometryHasBeenDestroyed) mesh->GeometryHasBeenDestroyed();
      G4VPhysicalVolume* pWorld
       = G4TransportationManager::GetTransportationManager()
         ->IsWorldExisting(ScM->GetWorldName(iw));
      if(!pWorld)
      {
        G4ExceptionDescription ed;
        ed<<"Mesh name <"<<ScM->GetWorldName(iw)<<"> is not found in the master thread.";
        G4Exception("G4WorkerRunManager::ConstructScoringWorlds()","RUN79001",
                      FatalException,ed);
      }
      if(!(mesh->GetMeshElementLogical()))
      {
        G4AutoLock l(&ConstructScoringWorldsMutex);
        G4VScoringMesh* masterMesh = masterScM->GetMesh(iw);
        mesh->SetMeshElementLogical(masterMesh->GetMeshElementLogical());
        l.unlock();
        
        G4ParallelWorldProcess* theParallelWorldProcess = mesh->GetParallelWorldProcess();
        if(theParallelWorldProcess)
        { theParallelWorldProcess->SetParallelWorld(ScM->GetWorldName(iw)); }
        else
        {
          theParallelWorldProcess = new G4ParallelWorldProcess(ScM->GetWorldName(iw));
          mesh->SetParallelWorldProcess(theParallelWorldProcess);
          theParallelWorldProcess->SetParallelWorld(ScM->GetWorldName(iw));

          particleIterator->reset();
          while( (*particleIterator)() ){
            G4ParticleDefinition* particle = particleIterator->value();
            G4ProcessManager* pmanager = particle->GetProcessManager();
            if(pmanager)
            {
              pmanager->AddProcess(theParallelWorldProcess);
              if(theParallelWorldProcess->IsAtRestRequired(particle))
              { pmanager->SetProcessOrdering(theParallelWorldProcess, idxAtRest, 9900); }
              pmanager->SetProcessOrderingToSecond(theParallelWorldProcess, idxAlongStep);
              pmanager->SetProcessOrdering(theParallelWorldProcess, idxPostStep, 9900);
            } //if(pmanager)
          }//while
        }
      }
      mesh->WorkerConstruct(pWorld);
    }
}

Here is the call graph for this function:

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

virtual

Reimplemented from G4RunManager.

Definition at line 204 of file G4WorkerRunManager.cc.

{
    if(!userPrimaryGeneratorAction)
    {
      G4Exception("G4RunManager::GenerateEvent()", "Run0032", FatalException,
                "G4VUserPrimaryGeneratorAction is not defined!");
    }

    //This is the same as in the sequential case, just the for-loop indexes are
    //different
    InitializeEventLoop(n_event,macroFile,n_select);

    // Reset random number seeds queue
    while(seedsQueue.size()>0)
    { seedsQueue.pop(); }
    // for each run, worker should receive at least one set of random number seeds.
    runIsSeeded = false; 

    // Event loop
    eventLoopOnGoing = true;
    G4int i_event = -1;
    nevModulo = -1;
    currEvID = -1;

    while(eventLoopOnGoing)
    {
      ProcessOneEvent(i_event);
      if(eventLoopOnGoing)
      {
        TerminateOneEvent();
        if(runAborted)
        { eventLoopOnGoing = false; }
      }
    }
     
    TerminateEventLoop();
}

Here is the call graph for this function:

void G4WorkerRunManager::DoWork ( )

virtual

Definition at line 588 of file G4WorkerRunManager.cc.

{
  G4MTRunManager* mrm = G4MTRunManager::GetMasterRunManager();
  G4MTRunManager::WorkerActionRequest nextAction = mrm->ThisWorkerWaitForNextAction();
  while( nextAction != G4MTRunManager::WorkerActionRequest::ENDWORKER )
  {
    if( nextAction == G4MTRunManager::WorkerActionRequest::NEXTITERATION ) // start the next run
    {
      //The following code deals with changing materials between runs
      static G4ThreadLocal G4bool skipInitialization = true;
      if(skipInitialization)
      {
        // re-initialization is not necessary for the first run
        skipInitialization = false;
      }
      else
      {
//        ReinitializeGeometry();
          workerContext->UpdateGeometryAndPhysicsVectorFromMaster();
      }

      // Execute UI commands stored in the master UI manager
      std::vector<G4String> cmds = mrm->GetCommandStack();
      G4UImanager* uimgr = G4UImanager::GetUIpointer(); //TLS instance
      std::vector<G4String>::const_iterator it = cmds.begin();
      for(;it!=cmds.end();it++)
      { uimgr->ApplyCommand(*it); }
      //Start this run
      G4int numevents = mrm->GetNumberOfEventsToBeProcessed();
      G4String macroFile = mrm->GetSelectMacro();
      G4int numSelect = mrm->GetNumberOfSelectEvents();
      if ( macroFile == "" || macroFile == " " )
      {
          this->BeamOn(numevents);
      }
      else
      {
          this->BeamOn(numevents,macroFile,numSelect);
      }
    }
    else if (nextAction == G4MTRunManager::WorkerActionRequest::PROCESSUI ) {
        std::vector<G4String> cmds = mrm->GetCommandStack();
        G4UImanager* uimgr = G4UImanager::GetUIpointer(); //TLS instance
        std::vector<G4String>::const_iterator it = cmds.begin();
        for(;it!=cmds.end();it++)
        { uimgr->ApplyCommand(*it); }
        mrm->ThisWorkerProcessCommandsStackDone();
    }
    else
    {
      G4ExceptionDescription d;
      d<<"Cannot continue, this worker has been requested an unknwon action: "
       <<static_cast<std::underlying_type<G4MTRunManager::WorkerActionRequest>::type>(nextAction);
      G4Exception("G4WorkerRunManager::DoWork","Run0104",FatalException,d);
    }

    //Now wait for master thread to signal new action to be performed
    nextAction = mrm->ThisWorkerWaitForNextAction();
  } //No more actions to perform

  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4Event * G4WorkerRunManager::GenerateEvent ( G4int  i_event )

virtual

Reimplemented from G4RunManager.

Definition at line 260 of file G4WorkerRunManager.cc.

{
  G4Event* anEvent = new G4Event(i_event);
  long s1 = 0;
  long s2 = 0;
  long s3 = 0;
  G4bool eventHasToBeSeeded = true;
  if(G4MTRunManager::SeedOncePerCommunication()==1 && runIsSeeded)
  { eventHasToBeSeeded = false; }

  if(i_event<0)
  {
    G4int nevM = G4MTRunManager::GetMasterRunManager()->GetEventModulo();
    if(nevM==1)
    {
      eventLoopOnGoing = G4MTRunManager::GetMasterRunManager()
                       ->SetUpAnEvent(anEvent,s1,s2,s3,eventHasToBeSeeded);
      runIsSeeded = true;
    }
    else
    {
      if(nevModulo<=0)
      {
        G4int nevToDo = G4MTRunManager::GetMasterRunManager()
                         ->SetUpNEvents(anEvent,&seedsQueue,eventHasToBeSeeded);
        if(nevToDo==0)
        { eventLoopOnGoing = false; }
        else
        {
          currEvID = anEvent->GetEventID();
          nevModulo = nevToDo - 1;
        }
      }
      else
      {
        if(G4MTRunManager::SeedOncePerCommunication()>0) eventHasToBeSeeded = false;
        anEvent->SetEventID(++currEvID);
        nevModulo--;
      }
      if(eventLoopOnGoing && eventHasToBeSeeded)
      {
        s1 = seedsQueue.front(); seedsQueue.pop();
        s2 = seedsQueue.front(); seedsQueue.pop();
      }
    }

    if(!eventLoopOnGoing)
    {
      delete anEvent;
      return 0;
    }
  }
  else if(eventHasToBeSeeded)
  {
    //Need to reseed random number generator
    G4RNGHelper* helper = G4RNGHelper::GetInstance();
    s1 = helper->GetSeed(i_event*2);
    s2 = helper->GetSeed(i_event*2+1);
  }

  if(eventHasToBeSeeded) 
  {
    long seeds[3] = { s1, s2, 0 };
    G4Random::setTheSeeds(seeds,-1);
    runIsSeeded = true;
  }

  //Read from file seed.
  //Andrea Dotti 4 November 2015
  //This is required for strong-reproducibility, in MT mode we have that each
  //thread produces, for each event a status file, we want to do that.
  //Search a random file with the format run{%d}evt{%d}.rndm

  //This is the filename base constructed from run and event
  const auto filename = [&] {
      std::ostringstream os;
      os << "run"<<currentRun->GetRunID() << "evt" << anEvent->GetEventID();
      return os.str();
  };

  G4bool RNGstatusReadFromFile = false;
 if ( readStatusFromFile ) {
     //Build full path of RNG status file for this event
     std::ostringstream os;
     os << filename() << ".rndm";
     const G4String& randomStatusFile = os.str();
     std::ifstream ifile(randomStatusFile.c_str());
     if ( ifile ) { //File valid and readable
         RNGstatusReadFromFile = true;
         G4Random::restoreEngineStatus(randomStatusFile.c_str());
     }
 }


  if(storeRandomNumberStatusToG4Event==1 || storeRandomNumberStatusToG4Event==3)
  {
    std::ostringstream oss;
    G4Random::saveFullState(oss);
    randomNumberStatusForThisEvent = oss.str();
    anEvent->SetRandomNumberStatus(randomNumberStatusForThisEvent);
  }

  if(storeRandomNumberStatus && ! RNGstatusReadFromFile ) { //If reading from file, avoid to rewrite the same
      G4String fileN = "currentEvent";
      if ( rngStatusEventsFlag ) {
          fileN = filename();
      }
      StoreRNGStatus(fileN);
  }

  if(printModulo > 0 && anEvent->GetEventID()%printModulo == 0 )
  {
    G4cout << "--> Event " << anEvent->GetEventID() << " starts";
    if(eventHasToBeSeeded)
    { G4cout << " with initial seeds (" << s1 << "," << s2 << ")"; }
    G4cout << "." << G4endl;
  }
  userPrimaryGeneratorAction->GeneratePrimaries(anEvent);
  return anEvent;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4WorkerRunManager * G4WorkerRunManager::GetWorkerRunManager ( )

static

Definition at line 52 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4WorkerRunManagerKernel * G4WorkerRunManager::GetWorkerRunManagerKernel ( )

static

Definition at line 55 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

void G4WorkerRunManager::InitializeGeometry ( )

virtual

Reimplemented from G4RunManager.

Definition at line 109 of file G4WorkerRunManager.cc.

                                            {
    if(!userDetector)
    {
        G4Exception("G4RunManager::InitializeGeometry", "Run0033",
                    FatalException, "G4VUserDetectorConstruction is not defined!");
        return;
    }
    if(fGeometryHasBeenDestroyed) 
    { G4TransportationManager::GetTransportationManager()->ClearParallelWorlds(); }

    //Step1: Get pointer to the physiWorld (note: needs to get the "super pointer, i.e. the one shared by all threads"
    G4RunManagerKernel* masterKernel = G4MTRunManager::GetMasterRunManagerKernel();
    G4VPhysicalVolume* worldVol = masterKernel->GetCurrentWorld();
    //Step2:, Call a new "WorkerDefineWorldVolume( pointer from 2-, false); 
    kernel->WorkerDefineWorldVolume(worldVol,false);
    kernel->SetNumberOfParallelWorld(masterKernel->GetNumberOfParallelWorld());
    //Step3: Call user's ConstructSDandField()
    userDetector->ConstructSDandField();
    userDetector->ConstructParallelSD();
    geometryInitialized = true;
}

Here is the call graph for this function:

void G4WorkerRunManager::MergePartialResults ( )

protectedvirtual

Definition at line 382 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4WorkerRunManager::ProcessOneEvent ( G4int  i_event )

virtual

Reimplemented from G4RunManager.

Definition at line 248 of file G4WorkerRunManager.cc.

{
  currentEvent = GenerateEvent(i_event);
  if(eventLoopOnGoing)
  {  
    eventManager->ProcessOneEvent(currentEvent);
    AnalyzeEvent(currentEvent);
    UpdateScoring();
    if(currentEvent->GetEventID()<n_select_msg) G4UImanager::GetUIpointer()->ApplyCommand(msgText);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void G4WorkerRunManager::RestoreRndmEachEvent ( G4bool  flag )

inlinevirtual

Reimplemented from G4RunManager.

Definition at line 106 of file G4WorkerRunManager.hh.

{ readStatusFromFile = flag; }

void G4WorkerRunManager::RunInitialization ( )

virtual

Reimplemented from G4RunManager.

Definition at line 133 of file G4WorkerRunManager.cc.

{
#ifdef G4MULTITHREADED
  if(!visIsSetUp)
  {
    G4VVisManager* pVVis = G4VVisManager::GetConcreteInstance();
    if(pVVis)
    {
      pVVis->SetUpForAThread();
      visIsSetUp = true;
    }
  }
#endif

  if(!(kernel->RunInitialization(fakeRun))) return;

  //Signal this thread can start event loop.
  //Note this will return only when all threads reach this point
  G4MTRunManager::GetMasterRunManager()->ThisWorkerReady();
  if(fakeRun) return;

  const G4UserWorkerInitialization* uwi
       = G4MTRunManager::GetMasterRunManager()->GetUserWorkerInitialization();
  CleanUpPreviousEvents();
  if(currentRun) delete currentRun;
  currentRun = 0;

  if(fGeometryHasBeenDestroyed) G4ParallelWorldProcessStore::GetInstance()->UpdateWorlds();
  //Call a user hook: this is guaranteed all threads are "synchronized"
  if(uwi) uwi->WorkerRunStart();

  if(userRunAction) currentRun = userRunAction->GenerateRun();
  if(!currentRun) currentRun = new G4Run();

  currentRun->SetRunID(runIDCounter);
  currentRun->SetNumberOfEventToBeProcessed(numberOfEventToBeProcessed);

  currentRun->SetDCtable(DCtable);
  G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
  if(fSDM)
  { currentRun->SetHCtable(fSDM->GetHCtable()); }

  std::ostringstream oss;
    G4Random::saveFullState(oss);
  randomNumberStatusForThisRun = oss.str();
  currentRun->SetRandomNumberStatus(randomNumberStatusForThisRun);

  for(G4int i_prev=0;i_prev<n_perviousEventsToBeStored;i_prev++)
  { previousEvents->push_back((G4Event*)0); }

  if(printModulo>0 || verboseLevel>0)
  {
    G4cout << "### Run " << currentRun->GetRunID() << " starts on worker thread "
           << G4Threading::G4GetThreadId() << "." << G4endl;
  }
  if(userRunAction) userRunAction->BeginOfRunAction(currentRun);

  if(storeRandomNumberStatus) {
      G4String fileN = "currentRun";
      if ( rngStatusEventsFlag ) {
          std::ostringstream os;
          os << "run" << currentRun->GetRunID();
          fileN = os.str();
      }
      StoreRNGStatus(fileN);
  }

  runAborted = false;
  numberOfEventProcessed = 0;
}

Here is the call graph for this function:

void G4WorkerRunManager::RunTermination ( )

virtual

Reimplemented from G4RunManager.

Definition at line 391 of file G4WorkerRunManager.cc.

{
  if(!fakeRun)
  {
    MergePartialResults();
    
    //Call a user hook: note this is before the next barrier
    //so threads execute this method asyncrhonouzly
    //(TerminateRun allows for synch via G4RunAction::EndOfRun)
    const G4UserWorkerInitialization* uwi
       = G4MTRunManager::GetMasterRunManager()->GetUserWorkerInitialization();
    if(uwi) uwi->WorkerRunEnd();
  }

  G4RunManager::RunTermination();
  //Signal this thread has finished envent-loop.
  //Note this will return only whan all threads reach this point
  G4MTRunManager::GetMasterRunManager()->ThisWorkerEndEventLoop();

}

Here is the call graph for this function:

void G4WorkerRunManager::SetUserAction ( G4UserRunAction *  userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 539 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4WorkerRunManager::SetUserAction ( G4VUserPrimaryGeneratorAction *  userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 561 of file G4WorkerRunManager.cc.

{
    G4RunManager::SetUserAction(ua);
}

Here is the call graph for this function:

void G4WorkerRunManager::SetUserAction ( G4UserEventAction *  userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 556 of file G4WorkerRunManager.cc.

{
    G4RunManager::SetUserAction(ua);
}

Here is the call graph for this function:

void G4WorkerRunManager::SetUserAction ( G4UserStackingAction *  userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 566 of file G4WorkerRunManager.cc.

{
    G4RunManager::SetUserAction(ua);
}

Here is the call graph for this function:

void G4WorkerRunManager::SetUserAction ( G4UserTrackingAction *  userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 571 of file G4WorkerRunManager.cc.

{
    G4RunManager::SetUserAction(ua);
}

Here is the call graph for this function:

void G4WorkerRunManager::SetUserAction ( G4UserSteppingAction *  userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 576 of file G4WorkerRunManager.cc.

{
    G4RunManager::SetUserAction(ua);
}

Here is the call graph for this function:

void G4WorkerRunManager::SetUserInitialization ( G4VUserPhysicsList *  userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 533 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4WorkerRunManager::SetUserInitialization ( G4VUserDetectorConstruction *  userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 527 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

void G4WorkerRunManager::SetUserInitialization ( G4VUserActionInitialization *  userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 521 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

void G4WorkerRunManager::SetUserInitialization ( G4UserWorkerInitialization *  userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 509 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

void G4WorkerRunManager::SetUserInitialization ( G4UserWorkerThreadInitialization *  userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 515 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

void G4WorkerRunManager::SetWorkerThread ( G4WorkerThread *  wc )

inline

Sets the worker context.

Definition at line 79 of file G4WorkerRunManager.hh.

{ workerContext = wc; }

Here is the caller graph for this function:

void G4WorkerRunManager::StoreRNGStatus ( const G4String &  filenamePrefix )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 581 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4WorkerRunManager::TerminateEventLoop ( )

virtual

Reimplemented from G4RunManager.

Definition at line 412 of file G4WorkerRunManager.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

G4int G4WorkerRunManager::currEvID

protected

Definition at line 101 of file G4WorkerRunManager.hh.

G4bool G4WorkerRunManager::eventLoopOnGoing

protected

Definition at line 98 of file G4WorkerRunManager.hh.

G4int G4WorkerRunManager::nevModulo

protected

Definition at line 100 of file G4WorkerRunManager.hh.

G4bool G4WorkerRunManager::readStatusFromFile

protected

Definition at line 103 of file G4WorkerRunManager.hh.

G4bool G4WorkerRunManager::runIsSeeded

protected

Definition at line 99 of file G4WorkerRunManager.hh.

G4SeedsQueue G4WorkerRunManager::seedsQueue

protected

Definition at line 102 of file G4WorkerRunManager.hh.

---

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

• geant4.10.03.p01/source/run/include/G4WorkerRunManager.hh
• geant4.10.03.p01/source/run/src/G4WorkerRunManager.cc