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 G4EventGenerateEvent (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 G4VUserDetectorConstructionGetUserDetectorConstruction () const
const G4VUserPhysicsListGetUserPhysicsList () const
const G4UserRunActionGetUserRunAction () const
const G4VUserPrimaryGeneratorActionGetUserPrimaryGeneratorAction () const
const G4UserEventActionGetUserEventAction () const
const G4UserStackingActionGetUserStackingAction () const
const G4UserTrackingActionGetUserTrackingAction () const
const G4UserSteppingActionGetUserSteppingAction () const
void SetNumberOfAdditionalWaitingStacks (G4int iAdd)
const G4StringGetVersionString () 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 G4StringGetRandomNumberStoreDir () const
const G4StringGetRandomNumberStatusForThisRun () const
const G4StringGetRandomNumberStatusForThisEvent () 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 G4RunGetCurrentRun () const
const G4EventGetCurrentEvent () const
const G4EventGetPreviousEvent (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 G4RunManagerGetRunManager ()

Protected Member Functions

void StackPreviousEvent (G4Event *anEvent)
void UpdateScoring ()

Protected Attributes

G4RunManagerKernelkernel
G4EventManagereventManager
G4VUserDetectorConstructionuserDetector
G4VUserPhysicsListphysicsList
G4UserRunActionuserRunAction
G4VUserPrimaryGeneratorActionuserPrimaryGeneratorAction
G4UserEventActionuserEventAction
G4UserStackingActionuserStackingAction
G4UserTrackingActionuserTrackingAction
G4UserSteppingActionuserSteppingAction
G4bool geometryInitialized
G4bool physicsInitialized
G4bool runAborted
G4bool initializedAtLeastOnce
G4bool geometryToBeOptimized
G4int runIDCounter
G4int verboseLevel
G4Timertimer
G4DCtableDCtable
G4RuncurrentRun
G4EventcurrentEvent
std::vector< G4Event * > * previousEvents
G4int n_perviousEventsToBeStored
G4int numberOfEventToBeProcessed
G4bool storeRandomNumberStatus
G4int storeRandomNumberStatusToG4Event
G4String randomNumberStatusDir
G4String randomNumberStatusForThisRun
G4String randomNumberStatusForThisEvent
G4VPhysicalVolumecurrentWorld
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().

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().

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().

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().

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().

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