G4RunManager Class Reference

#include <G4RunManager.hh>


Public Member Functions

 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 InitializeGeometry ()
virtual void InitializePhysics ()
virtual G4bool ConfirmBeamOnCondition ()
virtual void RunInitialization ()
virtual void DoEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)
virtual void RunTermination ()
virtual void InitializeEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)
virtual void ProcessOneEvent (G4int i_event)
virtual void TerminateOneEvent ()
virtual void TerminateEventLoop ()
virtual G4Event * GenerateEvent (G4int i_event)
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)
void SetUserInitialization (G4VUserDetectorConstruction *userInit)
void SetUserInitialization (G4VUserPhysicsList *userInit)
void SetUserAction (G4UserRunAction *userAction)
void SetUserAction (G4VUserPrimaryGeneratorAction *userAction)
void SetUserAction (G4UserEventAction *userAction)
void SetUserAction (G4UserStackingAction *userAction)
void SetUserAction (G4UserTrackingAction *userAction)
void SetUserAction (G4UserSteppingAction *userAction)
const G4VUserDetectorConstruction * GetUserDetectorConstruction () const
const G4VUserPhysicsList * GetUserPhysicsList () 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 GeometryHasBeenModified ()
void PhysicsHasBeenModified ()
void CutOffHasBeenModified ()
void ReOptimizeMotherOf (G4VPhysicalVolume *)
void ReOptimize (G4LogicalVolume *)
void SetVerboseLevel (G4int vl)
G4int GetVerboseLevel () const
void SetGeometryToBeOptimized (G4bool vl)
G4bool GetGeometryToBeOptimized ()
void SetNumberOfEventsToBeStored (G4int val)
const G4Run * GetCurrentRun () const
const G4Event * GetCurrentEvent () const
const G4Event * GetPreviousEvent (G4int i) const
void SetRunIDCounter (G4int i)
G4int GetNumberOfParallelWorld () const
void SetNumberOfEventsToBeProcessed (G4int val)
void SetDCtable (G4DCtable *DCtbl)
void ConstructScoringWorlds ()

Static Public Member Functions

static G4RunManager * GetRunManager ()

Protected Member Functions

void StackPreviousEvent (G4Event *anEvent)
void UpdateScoring ()

Protected Attributes

G4RunManagerKernel * kernel
G4EventManager * eventManager
G4VUserDetectorConstruction * userDetector
G4VUserPhysicsList * physicsList
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
G4Timer * timer
G4DCtable * DCtable
G4Run * currentRun
G4Event * currentEvent
std::vector< G4Event * > * previousEvents
G4int n_perviousEventsToBeStored
G4int numberOfEventToBeProcessed
G4bool storeRandomNumberStatus
G4int storeRandomNumberStatusToG4Event
G4String randomNumberStatusDir
G4String randomNumberStatusForThisRun
G4String randomNumberStatusForThisEvent
G4VPhysicalVolume * currentWorld
G4int nParallelWorlds
G4String msgText
G4int n_select_msg
G4int numberOfEventProcessed

Detailed Description

Definition at line 96 of file G4RunManager.hh.

Constructor & Destructor Documentation

G4RunManager::G4RunManager (  ) 

Definition at line 65 of file G4RunManager.cc.

References G4ProcessTable::CreateMessenger(), G4ParticleTable::CreateMessenger(), eventManager, FatalException, G4Exception(), G4RunManagerKernel::GetEventManager(), G4ParticleTable::GetParticleTable(), G4ProcessTable::GetProcessTable(), kernel, previousEvents, randomNumberStatusDir, randomNumberStatusForThisEvent, randomNumberStatusForThisRun, and timer.

00066 :userDetector(0),physicsList(0),
00067  userRunAction(0),userPrimaryGeneratorAction(0),userEventAction(0),
00068  userStackingAction(0),userTrackingAction(0),userSteppingAction(0),
00069  geometryInitialized(false),physicsInitialized(false),
00070  runAborted(false),initializedAtLeastOnce(false),
00071  geometryToBeOptimized(true),runIDCounter(0),verboseLevel(0),DCtable(0),
00072  currentRun(0),currentEvent(0),n_perviousEventsToBeStored(0),
00073  numberOfEventToBeProcessed(0),storeRandomNumberStatus(false),
00074  storeRandomNumberStatusToG4Event(0),
00075  currentWorld(0),nParallelWorlds(0),msgText(" "),n_select_msg(-1),
00076  numberOfEventProcessed(0)
00077 {
00078   if(fRunManager)
00079   {
00080     G4Exception("G4RunManager::G4RunManager()", "Run0031",
00081                 FatalException, "G4RunManager constructed twice.");
00082   }
00083   fRunManager = this;
00084 
00085   kernel = new G4RunManagerKernel();
00086   eventManager = kernel->GetEventManager();
00087 
00088   timer = new G4Timer();
00089   runMessenger = new G4RunMessenger(this);
00090   previousEvents = new std::vector<G4Event*>;
00091   G4ParticleTable::GetParticleTable()->CreateMessenger();
00092   G4ProcessTable::GetProcessTable()->CreateMessenger();
00093   randomNumberStatusDir = "./";
00094   std::ostringstream oss;
00095   HepRandom::saveFullState(oss);
00096   randomNumberStatusForThisRun = oss.str();
00097   randomNumberStatusForThisEvent = oss.str();
00098 }

G4RunManager::~G4RunManager (  )  [virtual]

Definition at line 100 of file G4RunManager.cc.

References currentRun, G4ProcessTable::DeleteMessenger(), G4ParticleTable::DeleteMessenger(), G4cout, G4endl, G4State_Quit, G4StateManager::GetCurrentState(), G4ParticleTable::GetParticleTable(), G4ProcessTable::GetProcessTable(), G4StateManager::GetStateManager(), kernel, physicsList, previousEvents, G4StateManager::SetNewState(), timer, userDetector, userPrimaryGeneratorAction, userRunAction, and verboseLevel.

00101 {
00102   G4StateManager* pStateManager = G4StateManager::GetStateManager();
00103   // set the application state to the quite state
00104   if(pStateManager->GetCurrentState()!=G4State_Quit)
00105   {
00106     if(verboseLevel>0) G4cout << "G4 kernel has come to Quit state." << G4endl;
00107     pStateManager->SetNewState(G4State_Quit);
00108   }
00109 
00110   if(currentRun) delete currentRun;
00111   delete timer;
00112   delete runMessenger;
00113   G4ParticleTable::GetParticleTable()->DeleteMessenger();
00114   G4ProcessTable::GetProcessTable()->DeleteMessenger();
00115   delete previousEvents;
00116   if(userDetector)
00117   {
00118     delete userDetector;
00119     userDetector = 0;
00120     if(verboseLevel>1) G4cout << "UserDetectorConstruction deleted." << G4endl;
00121   }
00122   if(physicsList)
00123   {
00124     delete physicsList;
00125     physicsList = 0;
00126     if(verboseLevel>1) G4cout << "UserPhysicsList deleted." << G4endl;
00127   }
00128   if(userRunAction)
00129   {
00130     delete userRunAction;
00131     userRunAction = 0;
00132     if(verboseLevel>1) G4cout << "UserRunAction deleted." << G4endl;
00133   }
00134   if(userPrimaryGeneratorAction)
00135   {
00136     delete userPrimaryGeneratorAction;
00137     userPrimaryGeneratorAction = 0;
00138     if(verboseLevel>1) G4cout << "UserPrimaryGenerator deleted." << G4endl;
00139   }
00140 
00141   delete kernel;
00142 
00143   if(verboseLevel>1) G4cout << "RunManager is deleted." << G4endl;
00144   fRunManager = 0;
00145 }

Member Function Documentation

void G4RunManager::AbortEvent (  )  [virtual]

Definition at line 429 of file G4RunManager.cc.

References G4EventManager::AbortCurrentEvent(), currentEvent, eventManager, G4cerr, G4endl, G4State_EventProc, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), and G4Event::SetEventAborted().

Referenced by G4ExceptionHandler::Notify(), and G4RunMessenger::SetNewValue().

00430 {
00431   // This method is valid only for EventProc state
00432   G4ApplicationState currentState = 
00433     G4StateManager::GetStateManager()->GetCurrentState();
00434   if(currentState==G4State_EventProc)
00435   {
00436     currentEvent->SetEventAborted();
00437     eventManager->AbortCurrentEvent();
00438   }
00439   else
00440   {
00441     G4cerr << "Event is not in progress. AbortEevnt() ignored." << G4endl;
00442   }
00443 }

void G4RunManager::AbortRun ( G4bool  softAbort = false  )  [virtual]

Definition at line 409 of file G4RunManager.cc.

References G4EventManager::AbortCurrentEvent(), currentEvent, eventManager, G4cerr, G4endl, G4State_EventProc, G4State_GeomClosed, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), runAborted, and G4Event::SetEventAborted().

Referenced by G4ExceptionHandler::Notify(), and G4RunMessenger::SetNewValue().

00410 {
00411   // This method is valid only for GeomClosed or EventProc state
00412   G4ApplicationState currentState = 
00413     G4StateManager::GetStateManager()->GetCurrentState();
00414   if(currentState==G4State_GeomClosed || currentState==G4State_EventProc)
00415   {
00416     runAborted = true;
00417     if(currentState==G4State_EventProc && !softAbort)
00418     {
00419       currentEvent->SetEventAborted();
00420       eventManager->AbortCurrentEvent();
00421     }
00422   }
00423   else
00424   {
00425     G4cerr << "Run is not in progress. AbortRun() ignored." << G4endl;
00426   }
00427 }

void G4RunManager::AnalyzeEvent ( G4Event *  anEvent  )  [virtual]

Definition at line 320 of file G4RunManager.cc.

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

Referenced by ProcessOneEvent().

00321 {
00322   G4VPersistencyManager* fPersM = G4VPersistencyManager::GetPersistencyManager();
00323   if(fPersM) fPersM->Store(anEvent);
00324   currentRun->RecordEvent(anEvent);
00325 }

void G4RunManager::BeamOn ( G4int  n_event,
const char *  macroFile = 0,
G4int  n_select = -1 
) [virtual]

Definition at line 147 of file G4RunManager.cc.

References ConfirmBeamOnCondition(), ConstructScoringWorlds(), DoEventLoop(), numberOfEventToBeProcessed, RunInitialization(), and RunTermination().

Referenced by G4AdjointSimManager::RunAdjointSimulation(), and G4RunMessenger::SetNewValue().

00148 {
00149   G4bool cond = ConfirmBeamOnCondition();
00150   if(cond)
00151   {
00152     numberOfEventToBeProcessed = n_event;
00153     ConstructScoringWorlds();
00154     RunInitialization();
00155     if(n_event>0) DoEventLoop(n_event,macroFile,n_select);
00156     RunTermination();
00157   }
00158 }

G4bool G4RunManager::ConfirmBeamOnCondition (  )  [virtual]

Definition at line 160 of file G4RunManager.cc.

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

Referenced by BeamOn().

00161 {
00162   G4StateManager* stateManager = G4StateManager::GetStateManager();
00163 
00164   G4ApplicationState currentState = stateManager->GetCurrentState();
00165   if(currentState!=G4State_PreInit && currentState!=G4State_Idle)
00166   {
00167     G4cerr << "Illegal application state - BeamOn() ignored." << G4endl;
00168     return false;
00169   }
00170 
00171   if(!initializedAtLeastOnce)
00172   {
00173     G4cerr << " Geant4 kernel should be initialized" << G4endl;
00174     G4cerr << "before the first BeamOn(). - BeamOn ignored." << G4endl;
00175     return false;
00176   }
00177 
00178   if(!geometryInitialized || !physicsInitialized)
00179   {
00180     if(verboseLevel>0)
00181     {
00182       G4cout << "Start re-initialization because " << G4endl;
00183       if(!geometryInitialized) G4cout << "  Geometry" << G4endl;
00184       if(!physicsInitialized)  G4cout << "  Physics processes" << G4endl;
00185       G4cout << "has been modified since last Run." << G4endl;
00186     }
00187     Initialize();
00188   }
00189   return true;
00190 }

void G4RunManager::ConstructScoringWorlds (  ) 

Definition at line 530 of file G4RunManager.cc.

References G4ProcessManager::AddProcess(), GeometryHasBeenModified(), G4ParticleTable::GetIterator(), G4ScoringManager::GetMesh(), G4ScoringManager::GetNumberOfMesh(), G4TransportationManager::GetParallelWorld(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), G4ScoringManager::GetScoringManagerIfExist(), G4TransportationManager::GetTransportationManager(), G4ScoringManager::GetWorldName(), idxAlongStep, idxAtRest, idxPostStep, G4TransportationManager::IsWorldExisting(), G4ParticleTableIterator< K, V >::reset(), G4VPhysicalVolume::SetName(), G4ParallelWorldScoringProcess::SetParallelWorld(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToSecond(), and G4ParticleTableIterator< K, V >::value().

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

00531 {
00532   G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
00533   if(!ScM) return;
00534   G4int nPar = ScM->GetNumberOfMesh();
00535   if(nPar<1) return;
00536 
00537   G4ParticleTable::G4PTblDicIterator* theParticleIterator
00538    = G4ParticleTable::GetParticleTable()->GetIterator();
00539   for(G4int iw=0;iw<nPar;iw++)
00540   {
00541     G4VScoringMesh* mesh = ScM->GetMesh(iw);
00542     G4VPhysicalVolume* pWorld
00543        = G4TransportationManager::GetTransportationManager()
00544          ->IsWorldExisting(ScM->GetWorldName(iw));
00545     if(!pWorld)
00546     {
00547       pWorld = G4TransportationManager::GetTransportationManager()
00548          ->GetParallelWorld(ScM->GetWorldName(iw));
00549       pWorld->SetName(ScM->GetWorldName(iw));
00550 
00551       G4ParallelWorldScoringProcess* theParallelWorldScoringProcess
00552         = new G4ParallelWorldScoringProcess(ScM->GetWorldName(iw));
00553       theParallelWorldScoringProcess->SetParallelWorld(ScM->GetWorldName(iw));
00554 
00555       theParticleIterator->reset();
00556       while( (*theParticleIterator)() ){
00557         G4ParticleDefinition* particle = theParticleIterator->value();
00558         G4ProcessManager* pmanager = particle->GetProcessManager();
00559         if(pmanager)
00560         {
00561           pmanager->AddProcess(theParallelWorldScoringProcess);
00562           if(theParallelWorldScoringProcess->IsAtRestRequired(particle))
00563           { pmanager->SetProcessOrdering(theParallelWorldScoringProcess, idxAtRest, 9999); }
00564           pmanager->SetProcessOrderingToSecond(theParallelWorldScoringProcess, idxAlongStep);
00565           pmanager->SetProcessOrdering(theParallelWorldScoringProcess, idxPostStep, 9999);
00566         }
00567       }
00568     }
00569     mesh->Construct(pWorld);
00570   }
00571   GeometryHasBeenModified();
00572 }

void G4RunManager::CutOffHasBeenModified (  )  [inline]

Definition at line 403 of file G4RunManager.hh.

References G4cerr, and G4endl.

Referenced by G4RunMessenger::SetNewValue().

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

void G4RunManager::DefineWorldVolume ( G4VPhysicalVolume *  worldVol,
G4bool  topologyIsChanged = true 
) [virtual]

Definition at line 445 of file G4RunManager.cc.

References G4RunManagerKernel::DefineWorldVolume(), and kernel.

Referenced by G4GDMLMessenger::SetNewValue().

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

void G4RunManager::DoEventLoop ( G4int  n_event,
const char *  macroFile = 0,
G4int  n_select = -1 
) [virtual]

Definition at line 230 of file G4RunManager.cc.

References InitializeEventLoop(), ProcessOneEvent(), runAborted, TerminateEventLoop(), and TerminateOneEvent().

Referenced by BeamOn().

00231 {
00232   InitializeEventLoop(n_event,macroFile,n_select);
00233 
00234 // Event loop
00235   for(G4int i_event=0; i_event<n_event; i_event++ )
00236   {
00237     ProcessOneEvent(i_event);
00238     TerminateOneEvent();
00239     if(runAborted) break;
00240   }
00241 
00242   TerminateEventLoop();
00243 }

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

Definition at line 514 of file G4RunManager.cc.

References G4RunManagerKernel::DumpRegion(), and kernel.

00515 {
00516 //  kernel->UpdateRegion();
00517   kernel->DumpRegion(region);
00518 }

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

Definition at line 508 of file G4RunManager.cc.

References G4RunManagerKernel::DumpRegion(), and kernel.

Referenced by G4RunMessenger::SetNewValue().

00509 {
00510 //  kernel->UpdateRegion();
00511   kernel->DumpRegion(rname);
00512 }

G4Event * G4RunManager::GenerateEvent ( G4int  i_event  )  [virtual]

Definition at line 292 of file G4RunManager.cc.

References FatalException, G4Exception(), G4VUserPrimaryGeneratorAction::GeneratePrimaries(), randomNumberStatusDir, randomNumberStatusForThisEvent, G4Event::SetRandomNumberStatus(), storeRandomNumberStatus, storeRandomNumberStatusToG4Event, and userPrimaryGeneratorAction.

Referenced by ProcessOneEvent().

00293 {
00294   if(!userPrimaryGeneratorAction)
00295   {
00296     G4Exception("G4RunManager::GenerateEvent()", "Run0032", FatalException,
00297                 "G4VUserPrimaryGeneratorAction is not defined!");
00298     return 0;
00299   }
00300 
00301   G4Event* anEvent = new G4Event(i_event);
00302 
00303   if(storeRandomNumberStatusToG4Event==1 || storeRandomNumberStatusToG4Event==3)
00304   {
00305     std::ostringstream oss;
00306     HepRandom::saveFullState(oss);
00307     randomNumberStatusForThisEvent = oss.str();
00308     anEvent->SetRandomNumberStatus(randomNumberStatusForThisEvent);
00309   }
00310 
00311   if(storeRandomNumberStatus) {
00312     G4String fileN = randomNumberStatusDir + "currentEvent.rndm"; 
00313     HepRandom::saveEngineStatus(fileN);
00314   }  
00315     
00316   userPrimaryGeneratorAction->GeneratePrimaries(anEvent);
00317   return anEvent;
00318 }

void G4RunManager::GeometryHasBeenModified (  )  [inline]

Definition at line 388 of file G4RunManager.hh.

References G4RunManagerKernel::GeometryHasBeenModified(), and kernel.

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

00389     { kernel->GeometryHasBeenModified(); }

const G4Event* G4RunManager::GetCurrentEvent (  )  const [inline]

Definition at line 450 of file G4RunManager.hh.

References currentEvent.

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

00451     { return currentEvent; }

const G4Run* G4RunManager::GetCurrentRun (  )  const [inline]

Definition at line 446 of file G4RunManager.hh.

References currentRun.

Referenced by G4VSceneHandler::ProcessScene(), G4VisCommandSceneEndOfEventAction::SetNewValue(), and G4VisCommandReviewKeptEvents::SetNewValue().

00447     { return currentRun; }

G4int G4RunManager::GetFlagRandomNumberStatusToG4Event (  )  const [inline]

Definition at line 346 of file G4RunManager.hh.

References storeRandomNumberStatusToG4Event.

Referenced by G4RunMessenger::GetCurrentValue().

00347     { return storeRandomNumberStatusToG4Event; }

G4bool G4RunManager::GetGeometryToBeOptimized (  )  [inline]

Definition at line 436 of file G4RunManager.hh.

References geometryToBeOptimized.

00437     { return geometryToBeOptimized; }

G4int G4RunManager::GetNumberOfParallelWorld (  )  const [inline]

Definition at line 470 of file G4RunManager.hh.

References nParallelWorlds.

00471     { return nParallelWorlds; }

const G4Event* G4RunManager::GetPreviousEvent ( G4int  i  )  const [inline]

Definition at line 454 of file G4RunManager.hh.

References n_perviousEventsToBeStored, and previousEvents.

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

00455     {
00456       if(i>=1 && i<=n_perviousEventsToBeStored)
00457       { return (*previousEvents)[i-1]; }
00458       return 0;
00459     }

const G4String& G4RunManager::GetRandomNumberStatusForThisEvent (  )  const [inline]

Definition at line 378 of file G4RunManager.hh.

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

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

const G4String& G4RunManager::GetRandomNumberStatusForThisRun (  )  const [inline]

Definition at line 376 of file G4RunManager.hh.

References randomNumberStatusForThisRun.

00377     { return randomNumberStatusForThisRun; }

G4bool G4RunManager::GetRandomNumberStore (  )  const [inline]

Definition at line 352 of file G4RunManager.hh.

References storeRandomNumberStatus.

00353     { return storeRandomNumberStatus; }

const G4String& G4RunManager::GetRandomNumberStoreDir (  )  const [inline]

Definition at line 374 of file G4RunManager.hh.

References randomNumberStatusDir.

Referenced by G4RunMessenger::GetCurrentValue().

00375     { return randomNumberStatusDir; }

G4RunManager * G4RunManager::GetRunManager (  )  [static]

Definition at line 62 of file G4RunManager.cc.

Referenced by G4DigiManager::G4DigiManager(), G4ErrorRunManagerHelper::InitializePhysics(), G4ExceptionHandler::Notify(), G4VSceneHandler::ProcessScene(), G4AdjointSimManager::RunAdjointSimulation(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandReviewKeptEvents::SetNewValue(), and G4GDMLMessenger::SetNewValue().

00063 { return fRunManager; }

const G4VUserDetectorConstruction* G4RunManager::GetUserDetectorConstruction (  )  const [inline]

Definition at line 306 of file G4RunManager.hh.

References userDetector.

00307     { return userDetector; }

const G4UserEventAction* G4RunManager::GetUserEventAction (  )  const [inline]

Definition at line 314 of file G4RunManager.hh.

References userEventAction.

00315     { return userEventAction; }

const G4VUserPhysicsList* G4RunManager::GetUserPhysicsList (  )  const [inline]

Definition at line 308 of file G4RunManager.hh.

References physicsList.

00309     { return physicsList; }

const G4VUserPrimaryGeneratorAction* G4RunManager::GetUserPrimaryGeneratorAction (  )  const [inline]

Definition at line 312 of file G4RunManager.hh.

References userPrimaryGeneratorAction.

00313     { return userPrimaryGeneratorAction; }

const G4UserRunAction* G4RunManager::GetUserRunAction (  )  const [inline]

Definition at line 310 of file G4RunManager.hh.

References userRunAction.

00311     { return userRunAction; }

const G4UserStackingAction* G4RunManager::GetUserStackingAction (  )  const [inline]

Definition at line 316 of file G4RunManager.hh.

References userStackingAction.

00317     { return userStackingAction; }

const G4UserSteppingAction* G4RunManager::GetUserSteppingAction (  )  const [inline]

Definition at line 320 of file G4RunManager.hh.

References userSteppingAction.

00321     { return userSteppingAction; }

const G4UserTrackingAction* G4RunManager::GetUserTrackingAction (  )  const [inline]

Definition at line 318 of file G4RunManager.hh.

References userTrackingAction.

00319     { return userTrackingAction; }

G4int G4RunManager::GetVerboseLevel (  )  const [inline]

Definition at line 424 of file G4RunManager.hh.

References verboseLevel.

Referenced by G4RunMessenger::GetCurrentValue().

00425     { return verboseLevel; }

const G4String& G4RunManager::GetVersionString (  )  const [inline]

Definition at line 331 of file G4RunManager.hh.

References G4RunManagerKernel::GetVersionString(), and kernel.

00332     { return kernel->GetVersionString(); }

void G4RunManager::Initialize (  )  [virtual]

Definition at line 362 of file G4RunManager.cc.

References G4cerr, G4endl, G4State_Idle, G4State_PreInit, geometryInitialized, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), initializedAtLeastOnce, InitializeGeometry(), InitializePhysics(), and physicsInitialized.

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

00363 {
00364   G4StateManager* stateManager = G4StateManager::GetStateManager();
00365   G4ApplicationState currentState = stateManager->GetCurrentState();
00366   if(currentState!=G4State_PreInit && currentState!=G4State_Idle)
00367   {
00368     G4cerr << "Illegal application state - "
00369            << "G4RunManager::Initialize() ignored." << G4endl;
00370     return;
00371   }
00372 
00373   if(!geometryInitialized) InitializeGeometry();
00374   if(!physicsInitialized) InitializePhysics();
00375   initializedAtLeastOnce = true;
00376 }

void G4RunManager::InitializeEventLoop ( G4int  n_event,
const char *  macroFile = 0,
G4int  n_select = -1 
) [virtual]

Definition at line 245 of file G4RunManager.cc.

References msgText, n_select_msg, G4Timer::Start(), timer, and verboseLevel.

Referenced by DoEventLoop().

00246 {
00247   if(verboseLevel>0) 
00248   { timer->Start(); }
00249 
00250   n_select_msg = n_select;
00251   if(macroFile!=0)
00252   { 
00253     if(n_select_msg<0) n_select_msg = n_event;
00254     msgText = "/control/execute ";
00255     msgText += macroFile;
00256   }
00257   else
00258   { n_select_msg = -1; }
00259 }

void G4RunManager::InitializeGeometry (  )  [virtual]

Definition at line 378 of file G4RunManager.cc.

References G4VUserDetectorConstruction::Construct(), G4VUserDetectorConstruction::ConstructParallelGeometries(), G4RunManagerKernel::DefineWorldVolume(), FatalException, G4cout, G4endl, G4Exception(), geometryInitialized, kernel, nParallelWorlds, G4RunManagerKernel::SetNumberOfParallelWorld(), userDetector, and verboseLevel.

Referenced by Initialize().

00379 {
00380   if(!userDetector)
00381   {
00382     G4Exception("G4RunManager::InitializeGeometry", "Run0033",
00383                 FatalException, "G4VUserDetectorConstruction is not defined!");
00384     return;
00385   }
00386 
00387   if(verboseLevel>1) G4cout << "userDetector->Construct() start." << G4endl;
00388   kernel->DefineWorldVolume(userDetector->Construct(),false);
00389   nParallelWorlds = userDetector->ConstructParallelGeometries();
00390   kernel->SetNumberOfParallelWorld(nParallelWorlds);
00391   geometryInitialized = true;
00392 }

void G4RunManager::InitializePhysics (  )  [virtual]

Definition at line 394 of file G4RunManager.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4RunManagerKernel::InitializePhysics(), kernel, physicsInitialized, physicsList, and verboseLevel.

Referenced by Initialize().

00395 {
00396   if(physicsList)
00397   {
00398     if(verboseLevel>1) G4cout << "physicsList->Construct() start." << G4endl;
00399     kernel->InitializePhysics();
00400   }
00401   else
00402   {
00403     G4Exception("G4RunManager::InitializePhysics()", "Run0034",
00404                 FatalException, "G4VUserPhysicsList is not defined!");
00405   }
00406   physicsInitialized = true;
00407 }

void G4RunManager::PhysicsHasBeenModified (  )  [inline]

Definition at line 395 of file G4RunManager.hh.

References kernel, and G4RunManagerKernel::PhysicsHasBeenModified().

Referenced by G4RunMessenger::SetNewValue().

00396     { kernel->PhysicsHasBeenModified(); }

void G4RunManager::ProcessOneEvent ( G4int  i_event  )  [virtual]

Definition at line 261 of file G4RunManager.cc.

References AnalyzeEvent(), G4UImanager::ApplyCommand(), currentEvent, eventManager, GenerateEvent(), G4UImanager::GetUIpointer(), msgText, n_select_msg, G4EventManager::ProcessOneEvent(), and UpdateScoring().

Referenced by DoEventLoop().

00262 {
00263   currentEvent = GenerateEvent(i_event);
00264   eventManager->ProcessOneEvent(currentEvent);
00265   AnalyzeEvent(currentEvent);
00266   UpdateScoring();
00267   if(i_event<n_select_msg) G4UImanager::GetUIpointer()->ApplyCommand(msgText);
00268 }

void G4RunManager::ReOptimize ( G4LogicalVolume *   ) 

Definition at line 601 of file G4RunManager.cc.

References G4LogicalVolume::GetVoxelHeader(), and G4LogicalVolume::SetVoxelHeader().

Referenced by ReOptimizeMotherOf().

00602 {
00603   G4SmartVoxelHeader* header = pLog->GetVoxelHeader();
00604   delete header;
00605   header = new G4SmartVoxelHeader(pLog);
00606   pLog->SetVoxelHeader(header);
00607 }

void G4RunManager::ReOptimizeMotherOf ( G4VPhysicalVolume *   ) 

Definition at line 595 of file G4RunManager.cc.

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

00596 {
00597   G4LogicalVolume* pMotherL = pPhys->GetMotherLogical();
00598   if(pMotherL) ReOptimize(pMotherL);
00599 }

void G4RunManager::RestoreRandomNumberStatus ( const G4String &  fileN  )  [virtual]

Definition at line 494 of file G4RunManager.cc.

References G4cout, G4endl, G4String::index(), randomNumberStatusDir, and verboseLevel.

Referenced by G4RunMessenger::SetNewValue().

00495 {
00496   G4String fileNameWithDirectory;
00497   if(fileN.index("/")==std::string::npos)
00498   { fileNameWithDirectory = randomNumberStatusDir+fileN; }
00499   else
00500   { fileNameWithDirectory = fileN; }
00501   
00502   HepRandom::restoreEngineStatus(fileNameWithDirectory);
00503   if(verboseLevel>0) G4cout << "RandomNumberEngineStatus restored from file: "
00504          << fileNameWithDirectory << G4endl;
00505   HepRandom::showEngineStatus();         
00506 }

void G4RunManager::rndmSaveThisEvent (  )  [virtual]

Definition at line 473 of file G4RunManager.cc.

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

Referenced by G4RunMessenger::SetNewValue().

00474 {
00475   if(!storeRandomNumberStatus || currentEvent == 0) {
00476      G4cerr << "Warning from G4RunManager::rndmSaveThisEvent():"
00477           << " there is no currentEvent or its RandomEngineStatus is not available."
00478           << G4endl << "Command ignored." << G4endl;
00479      return;
00480   }
00481   
00482   G4String fileIn  = randomNumberStatusDir + "currentEvent.rndm";
00483 
00484   std::ostringstream os;
00485   os << "run" << currentRun->GetRunID() << "evt" << currentEvent->GetEventID()
00486      << ".rndm" << '\0';
00487   G4String fileOut = randomNumberStatusDir + os.str();       
00488 
00489   G4String copCmd = "/control/shell cp "+fileIn+" "+fileOut;
00490   G4UImanager::GetUIpointer()->ApplyCommand(copCmd);
00491   if(verboseLevel>0) G4cout << "currentEvent.rndm is copied to file: " << fileOut << G4endl;  
00492 }

void G4RunManager::rndmSaveThisRun (  )  [virtual]

Definition at line 451 of file G4RunManager.cc.

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

Referenced by G4RunMessenger::SetNewValue().

00452 {
00453   G4int runNumber = 0;
00454   if(currentRun) runNumber = currentRun->GetRunID();
00455   if(!storeRandomNumberStatus) {
00456      G4cerr << "Warning from G4RunManager::rndmSaveThisRun():"
00457           << " Random number status was not stored prior to this run." 
00458           << G4endl << "Command ignored." << G4endl;
00459      return;
00460   }
00461   
00462   G4String fileIn  = randomNumberStatusDir + "currentRun.rndm";
00463  
00464   std::ostringstream os;
00465   os << "run" << runNumber << ".rndm" << '\0';
00466   G4String fileOut = randomNumberStatusDir + os.str();  
00467 
00468   G4String copCmd = "/control/shell cp "+fileIn+" "+fileOut;
00469   G4UImanager::GetUIpointer()->ApplyCommand(copCmd);
00470   if(verboseLevel>0) G4cout << "currentRun.rndm is copied to file: " << fileOut << G4endl;    
00471 }

void G4RunManager::RunInitialization (  )  [virtual]

Definition at line 192 of file G4RunManager.cc.

References G4UserRunAction::BeginOfRunAction(), currentRun, DCtable, G4cout, G4endl, G4UserRunAction::GenerateRun(), G4SDManager::GetHCtable(), G4SDManager::GetSDMpointerIfExist(), kernel, n_perviousEventsToBeStored, numberOfEventProcessed, numberOfEventToBeProcessed, previousEvents, randomNumberStatusDir, randomNumberStatusForThisRun, runAborted, runIDCounter, G4RunManagerKernel::RunInitialization(), G4Run::SetDCtable(), G4Run::SetHCtable(), G4Run::SetNumberOfEventToBeProcessed(), G4Run::SetRandomNumberStatus(), G4Run::SetRunID(), storeRandomNumberStatus, userRunAction, and verboseLevel.

Referenced by BeamOn().

00193 {
00194   if(!(kernel->RunInitialization())) return;
00195   if(currentRun) delete currentRun;
00196   currentRun = 0;
00197 
00198   if(userRunAction) currentRun = userRunAction->GenerateRun();
00199   if(!currentRun) currentRun = new G4Run();
00200 
00201   currentRun->SetRunID(runIDCounter);
00202   currentRun->SetNumberOfEventToBeProcessed(numberOfEventToBeProcessed);
00203 
00204   currentRun->SetDCtable(DCtable);
00205   G4SDManager* fSDM = G4SDManager::GetSDMpointerIfExist();
00206   if(fSDM)
00207   { currentRun->SetHCtable(fSDM->GetHCtable()); }
00208   
00209   std::ostringstream oss;
00210   HepRandom::saveFullState(oss);
00211   randomNumberStatusForThisRun = oss.str();
00212   currentRun->SetRandomNumberStatus(randomNumberStatusForThisRun);
00213   
00214   previousEvents->clear();
00215   for(G4int i_prev=0;i_prev<n_perviousEventsToBeStored;i_prev++)
00216   { previousEvents->push_back((G4Event*)0); }
00217 
00218   if(userRunAction) userRunAction->BeginOfRunAction(currentRun);
00219 
00220   if(storeRandomNumberStatus) {
00221     G4String fileN = randomNumberStatusDir + "currentRun.rndm"; 
00222     HepRandom::saveEngineStatus(fileN);
00223   }
00224 
00225   runAborted = false;
00226   numberOfEventProcessed = 0;
00227   if(verboseLevel>0) G4cout << "Start Run processing." << G4endl;
00228 }

void G4RunManager::RunTermination (  )  [virtual]

Definition at line 327 of file G4RunManager.cc.

References currentRun, G4UserRunAction::EndOfRunAction(), G4VPersistencyManager::GetPersistencyManager(), kernel, n_perviousEventsToBeStored, previousEvents, runIDCounter, G4RunManagerKernel::RunTermination(), G4VPersistencyManager::Store(), and userRunAction.

Referenced by BeamOn().

00328 {
00329   for(size_t itr=0;itr<previousEvents->size();itr++)
00330   {
00331     G4Event* prevEv =  (*previousEvents)[itr];
00332     if((prevEv) && !(prevEv->ToBeKept())) delete prevEv;
00333   }
00334   previousEvents->clear();
00335   for(G4int i_prev=0;i_prev<n_perviousEventsToBeStored;i_prev++)
00336   { previousEvents->push_back((G4Event*)0); }
00337 
00338   if(userRunAction) userRunAction->EndOfRunAction(currentRun);
00339 
00340   G4VPersistencyManager* fPersM = G4VPersistencyManager::GetPersistencyManager();
00341   if(fPersM) fPersM->Store(currentRun);
00342   runIDCounter++;
00343 
00344   kernel->RunTermination();
00345 }

void G4RunManager::SetDCtable ( G4DCtable *  DCtbl  )  [inline]

Definition at line 474 of file G4RunManager.hh.

References DCtable.

Referenced by G4DigiManager::AddNewModule().

00475     { DCtable = DCtbl; }

void G4RunManager::SetGeometryToBeOptimized ( G4bool  vl  )  [inline]

Definition at line 427 of file G4RunManager.hh.

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

Referenced by G4RunMessenger::SetNewValue().

00428     { 
00429       if(geometryToBeOptimized != vl)
00430       {
00431         geometryToBeOptimized = vl;
00432         kernel->GeometryHasBeenModified();
00433         kernel->SetGeometryToBeOptimized(vl);
00434       }
00435     }

void G4RunManager::SetNumberOfAdditionalWaitingStacks ( G4int  iAdd  )  [inline]

Definition at line 324 of file G4RunManager.hh.

References eventManager, and G4EventManager::SetNumberOfAdditionalWaitingStacks().

00325     { eventManager->SetNumberOfAdditionalWaitingStacks(iAdd); }

void G4RunManager::SetNumberOfEventsToBeProcessed ( G4int  val  )  [inline]

Definition at line 472 of file G4RunManager.hh.

References numberOfEventToBeProcessed.

00473     { numberOfEventToBeProcessed = val; }

void G4RunManager::SetNumberOfEventsToBeStored ( G4int  val  )  [inline]

Definition at line 440 of file G4RunManager.hh.

References n_perviousEventsToBeStored.

00441     { n_perviousEventsToBeStored = val; }

void G4RunManager::SetPrimaryTransformer ( G4PrimaryTransformer *  pt  )  [inline]

Definition at line 334 of file G4RunManager.hh.

References kernel, and G4RunManagerKernel::SetPrimaryTransformer().

00335     { kernel->SetPrimaryTransformer(pt); }

void G4RunManager::SetRandomNumberStore ( G4bool  flag  )  [inline]

Definition at line 350 of file G4RunManager.hh.

References storeRandomNumberStatus.

Referenced by G4RunMessenger::SetNewValue().

00351     { storeRandomNumberStatus = flag; }

void G4RunManager::SetRandomNumberStoreDir ( const G4String &  dir  )  [inline]

Definition at line 354 of file G4RunManager.hh.

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

Referenced by G4RunMessenger::SetNewValue().

00355     { 
00356       G4String dirStr = dir;
00357       if( dirStr(dirStr.length()-1) != '/' ) dirStr += "/";
00358 #ifndef WIN32
00359       G4String shellCmd = "mkdir -p ";
00360 #else
00361       std::replace(dirStr.begin(), dirStr.end(),'/','\\');
00362       G4String shellCmd = "if not exist " + dirStr + " mkdir ";
00363 #endif
00364       shellCmd += dirStr;
00365       randomNumberStatusDir = dirStr;
00366       G4int sysret = system(shellCmd);
00367       if(sysret!=0)
00368       { 
00369         G4String errmsg = "\"" + shellCmd + "\" returns non-zero value. Directory creation failed.";
00370         G4Exception("GrRunManager::SetRandomNumberStoreDir","Run0071",JustWarning,errmsg);
00371         G4cerr << " return value = " << sysret << G4endl;
00372       }
00373     }

void G4RunManager::SetRunIDCounter ( G4int  i  )  [inline]

Definition at line 464 of file G4RunManager.hh.

References runIDCounter.

00465     { runIDCounter = i; }

void G4RunManager::SetUserAction ( G4UserSteppingAction *  userAction  )  [inline]

Definition at line 300 of file G4RunManager.hh.

References eventManager, G4EventManager::SetUserAction(), and userSteppingAction.

00301     { 
00302       eventManager->SetUserAction(userAction); 
00303       userSteppingAction = userAction;
00304     }

void G4RunManager::SetUserAction ( G4UserTrackingAction *  userAction  )  [inline]

Definition at line 295 of file G4RunManager.hh.

References eventManager, G4EventManager::SetUserAction(), and userTrackingAction.

00296     { 
00297       eventManager->SetUserAction(userAction); 
00298       userTrackingAction = userAction;
00299     }

void G4RunManager::SetUserAction ( G4UserStackingAction *  userAction  )  [inline]

Definition at line 290 of file G4RunManager.hh.

References eventManager, G4EventManager::SetUserAction(), and userStackingAction.

00291     { 
00292       eventManager->SetUserAction(userAction); 
00293       userStackingAction = userAction;
00294     }

void G4RunManager::SetUserAction ( G4UserEventAction *  userAction  )  [inline]

Definition at line 285 of file G4RunManager.hh.

References eventManager, G4EventManager::SetUserAction(), and userEventAction.

00286     { 
00287       eventManager->SetUserAction(userAction); 
00288       userEventAction = userAction;
00289     }

void G4RunManager::SetUserAction ( G4VUserPrimaryGeneratorAction *  userAction  )  [inline]

Definition at line 283 of file G4RunManager.hh.

References userPrimaryGeneratorAction.

00284     { userPrimaryGeneratorAction = userAction; }

void G4RunManager::SetUserAction ( G4UserRunAction *  userAction  )  [inline]

Definition at line 281 of file G4RunManager.hh.

References userRunAction.

00282     { userRunAction = userAction; }

void G4RunManager::SetUserInitialization ( G4VUserPhysicsList *  userInit  )  [inline]

Definition at line 276 of file G4RunManager.hh.

References kernel, physicsList, and G4RunManagerKernel::SetPhysics().

00277     {
00278       physicsList = userInit;
00279       kernel->SetPhysics(userInit);
00280     }

void G4RunManager::SetUserInitialization ( G4VUserDetectorConstruction *  userInit  )  [inline]

Definition at line 274 of file G4RunManager.hh.

References userDetector.

00275     { userDetector = userInit; }

void G4RunManager::SetVerboseLevel ( G4int  vl  )  [inline]

Definition at line 421 of file G4RunManager.hh.

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

Referenced by G4RunMessenger::SetNewValue().

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

void G4RunManager::StackPreviousEvent ( G4Event *  anEvent  )  [protected]

Definition at line 347 of file G4RunManager.cc.

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

Referenced by TerminateOneEvent().

00348 {
00349   if(anEvent->ToBeKept()) currentRun->StoreEvent(anEvent);
00350   G4Event* evt;
00351   if(n_perviousEventsToBeStored==0)
00352   { evt = anEvent; }
00353   else
00354   {
00355     previousEvents->insert(previousEvents->begin(),anEvent);
00356     evt = previousEvents->back();
00357     previousEvents->pop_back();
00358   }
00359   if(evt && !(evt->ToBeKept())) delete evt;
00360 }

void G4RunManager::StoreRandomNumberStatusToG4Event ( G4int  vl  )  [inline]

Definition at line 337 of file G4RunManager.hh.

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

Referenced by G4RunMessenger::SetNewValue().

00338                    : status before primary particle generation is stored
00339       // if vl = 2 : status before event processing (after primary particle generation) is stored
00340       // if vl = 3 : both are stored
00341       // if vl = 0 : none is stored (default)
00342     { 
00343       storeRandomNumberStatusToG4Event = vl;
00344       eventManager->StoreRandomNumberStatusToG4Event(vl);
00345     }

void G4RunManager::TerminateEventLoop (  )  [virtual]

Definition at line 277 of file G4RunManager.cc.

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

Referenced by DoEventLoop().

00278 {
00279   if(verboseLevel>0)
00280   {
00281     timer->Stop();
00282     G4cout << "Run terminated." << G4endl;
00283     G4cout << "Run Summary" << G4endl;
00284     if(runAborted)
00285     { G4cout << "  Run Aborted after " << numberOfEventProcessed << " events processed." << G4endl; }
00286     else
00287     { G4cout << "  Number of events processed : " << numberOfEventProcessed << G4endl; }
00288     G4cout << "  "  << *timer << G4endl;
00289   }
00290 }

void G4RunManager::TerminateOneEvent (  )  [virtual]

Definition at line 270 of file G4RunManager.cc.

References currentEvent, numberOfEventProcessed, and StackPreviousEvent().

Referenced by DoEventLoop().

00271 {
00272   StackPreviousEvent(currentEvent);
00273   currentEvent = 0;
00274   numberOfEventProcessed++;
00275 }

void G4RunManager::UpdateScoring (  )  [protected]

Definition at line 574 of file G4RunManager.cc.

References G4ScoringManager::Accumulate(), currentEvent, G4HCofThisEvent::GetCapacity(), G4HCofThisEvent::GetHC(), G4Event::GetHCofThisEvent(), G4ScoringManager::GetNumberOfMesh(), and G4ScoringManager::GetScoringManagerIfExist().

Referenced by ProcessOneEvent().

00575 {
00576   G4ScoringManager* ScM = G4ScoringManager::GetScoringManagerIfExist();
00577   if(!ScM) return;
00578   G4int nPar = ScM->GetNumberOfMesh();
00579   if(nPar<1) return;
00580 
00581   G4HCofThisEvent* HCE = currentEvent->GetHCofThisEvent();
00582   if(!HCE) return;
00583   G4int nColl = HCE->GetCapacity();
00584   for(G4int i=0;i<nColl;i++)
00585   {
00586     G4VHitsCollection* HC = HCE->GetHC(i);
00587     if(HC) ScM->Accumulate(HC);
00588   }
00589 }

Field Documentation

G4Event* G4RunManager::currentEvent [protected]

Definition at line 249 of file G4RunManager.hh.

Referenced by AbortEvent(), AbortRun(), GetCurrentEvent(), ProcessOneEvent(), rndmSaveThisEvent(), TerminateOneEvent(), and UpdateScoring().

G4Run* G4RunManager::currentRun [protected]

Definition at line 248 of file G4RunManager.hh.

Referenced by AnalyzeEvent(), GetCurrentRun(), rndmSaveThisEvent(), rndmSaveThisRun(), RunInitialization(), RunTermination(), StackPreviousEvent(), and ~G4RunManager().

G4VPhysicalVolume* G4RunManager::currentWorld [protected]

Definition at line 260 of file G4RunManager.hh.

G4DCtable* G4RunManager::DCtable [protected]

Definition at line 246 of file G4RunManager.hh.

Referenced by RunInitialization(), and SetDCtable().

G4EventManager* G4RunManager::eventManager [protected]

Definition at line 222 of file G4RunManager.hh.

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

G4bool G4RunManager::geometryInitialized [protected]

Definition at line 237 of file G4RunManager.hh.

Referenced by ConfirmBeamOnCondition(), Initialize(), and InitializeGeometry().

G4bool G4RunManager::geometryToBeOptimized [protected]

Definition at line 241 of file G4RunManager.hh.

Referenced by GetGeometryToBeOptimized(), and SetGeometryToBeOptimized().

G4bool G4RunManager::initializedAtLeastOnce [protected]

Definition at line 240 of file G4RunManager.hh.

Referenced by ConfirmBeamOnCondition(), and Initialize().

G4RunManagerKernel* G4RunManager::kernel [protected]

Definition at line 221 of file G4RunManager.hh.

Referenced by DefineWorldVolume(), DumpRegion(), G4RunManager(), GeometryHasBeenModified(), GetVersionString(), InitializeGeometry(), InitializePhysics(), PhysicsHasBeenModified(), RunInitialization(), RunTermination(), SetGeometryToBeOptimized(), SetPrimaryTransformer(), SetUserInitialization(), SetVerboseLevel(), and ~G4RunManager().

G4String G4RunManager::msgText [protected]

Definition at line 264 of file G4RunManager.hh.

Referenced by InitializeEventLoop(), and ProcessOneEvent().

G4int G4RunManager::n_perviousEventsToBeStored [protected]

Definition at line 251 of file G4RunManager.hh.

Referenced by GetPreviousEvent(), RunInitialization(), RunTermination(), SetNumberOfEventsToBeStored(), and StackPreviousEvent().

G4int G4RunManager::n_select_msg [protected]

Definition at line 265 of file G4RunManager.hh.

Referenced by InitializeEventLoop(), and ProcessOneEvent().

G4int G4RunManager::nParallelWorlds [protected]

Definition at line 262 of file G4RunManager.hh.

Referenced by GetNumberOfParallelWorld(), and InitializeGeometry().

G4int G4RunManager::numberOfEventProcessed [protected]

Definition at line 266 of file G4RunManager.hh.

Referenced by RunInitialization(), TerminateEventLoop(), and TerminateOneEvent().

G4int G4RunManager::numberOfEventToBeProcessed [protected]

Definition at line 252 of file G4RunManager.hh.

Referenced by BeamOn(), RunInitialization(), and SetNumberOfEventsToBeProcessed().

G4bool G4RunManager::physicsInitialized [protected]

Definition at line 238 of file G4RunManager.hh.

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

G4VUserPhysicsList* G4RunManager::physicsList [protected]

Definition at line 225 of file G4RunManager.hh.

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

std::vector<G4Event*>* G4RunManager::previousEvents [protected]

Definition at line 250 of file G4RunManager.hh.

Referenced by G4RunManager(), GetPreviousEvent(), RunInitialization(), RunTermination(), StackPreviousEvent(), and ~G4RunManager().

G4String G4RunManager::randomNumberStatusDir [protected]

Definition at line 256 of file G4RunManager.hh.

Referenced by G4RunManager(), GenerateEvent(), GetRandomNumberStoreDir(), RestoreRandomNumberStatus(), rndmSaveThisEvent(), rndmSaveThisRun(), RunInitialization(), and SetRandomNumberStoreDir().

G4String G4RunManager::randomNumberStatusForThisEvent [protected]

Definition at line 258 of file G4RunManager.hh.

Referenced by G4RunManager(), GenerateEvent(), and GetRandomNumberStatusForThisEvent().

G4String G4RunManager::randomNumberStatusForThisRun [protected]

Definition at line 257 of file G4RunManager.hh.

Referenced by G4RunManager(), GetRandomNumberStatusForThisRun(), and RunInitialization().

G4bool G4RunManager::runAborted [protected]

Definition at line 239 of file G4RunManager.hh.

Referenced by AbortRun(), DoEventLoop(), RunInitialization(), and TerminateEventLoop().

G4int G4RunManager::runIDCounter [protected]

Definition at line 243 of file G4RunManager.hh.

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

G4bool G4RunManager::storeRandomNumberStatus [protected]

Definition at line 254 of file G4RunManager.hh.

Referenced by GenerateEvent(), GetRandomNumberStore(), rndmSaveThisEvent(), rndmSaveThisRun(), RunInitialization(), and SetRandomNumberStore().

G4int G4RunManager::storeRandomNumberStatusToG4Event [protected]

Definition at line 255 of file G4RunManager.hh.

Referenced by GenerateEvent(), GetFlagRandomNumberStatusToG4Event(), GetRandomNumberStatusForThisEvent(), and StoreRandomNumberStatusToG4Event().

G4Timer* G4RunManager::timer [protected]

Definition at line 245 of file G4RunManager.hh.

Referenced by G4RunManager(), InitializeEventLoop(), TerminateEventLoop(), and ~G4RunManager().

G4VUserDetectorConstruction* G4RunManager::userDetector [protected]

Definition at line 224 of file G4RunManager.hh.

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

G4UserEventAction* G4RunManager::userEventAction [protected]

Definition at line 228 of file G4RunManager.hh.

Referenced by GetUserEventAction(), and SetUserAction().

G4VUserPrimaryGeneratorAction* G4RunManager::userPrimaryGeneratorAction [protected]

Definition at line 227 of file G4RunManager.hh.

Referenced by GenerateEvent(), GetUserPrimaryGeneratorAction(), SetUserAction(), and ~G4RunManager().

G4UserRunAction* G4RunManager::userRunAction [protected]

Definition at line 226 of file G4RunManager.hh.

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

G4UserStackingAction* G4RunManager::userStackingAction [protected]

Definition at line 229 of file G4RunManager.hh.

Referenced by GetUserStackingAction(), and SetUserAction().

G4UserSteppingAction* G4RunManager::userSteppingAction [protected]

Definition at line 231 of file G4RunManager.hh.

Referenced by GetUserSteppingAction(), and SetUserAction().

G4UserTrackingAction* G4RunManager::userTrackingAction [protected]

Definition at line 230 of file G4RunManager.hh.

Referenced by GetUserTrackingAction(), and SetUserAction().

G4int G4RunManager::verboseLevel [protected]

Definition at line 244 of file G4RunManager.hh.

Referenced by ConfirmBeamOnCondition(), GetVerboseLevel(), InitializeEventLoop(), InitializeGeometry(), InitializePhysics(), RestoreRandomNumberStatus(), rndmSaveThisEvent(), rndmSaveThisRun(), RunInitialization(), SetVerboseLevel(), TerminateEventLoop(), and ~G4RunManager().

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:53:20 2013 for Geant4 by  doxygen 1.4.7