G4EventManager Class Reference

#include <G4EventManager.hh>

Public Types
using	ProfilerConfig = G4ProfilerConfig< G4ProfileType::Event >

Public Member Functions
void	AbortCurrentEvent ()
	G4EventManager ()
	G4EventManager (const G4EventManager &right)=delete
const G4Event *	GetConstCurrentEvent ()
G4Event *	GetNonconstCurrentEvent ()
G4PrimaryTransformer *	GetPrimaryTransformer () const
G4StackManager *	GetStackManager () const
G4TrackingManager *	GetTrackingManager () const
G4UserEventAction *	GetUserEventAction ()
G4VUserEventInformation *	GetUserInformation ()
G4UserStackingAction *	GetUserStackingAction ()
G4UserSteppingAction *	GetUserSteppingAction ()
G4UserTrackingAction *	GetUserTrackingAction ()
G4int	GetVerboseLevel ()
void	KeepTheCurrentEvent ()
G4EventManager &	operator= (const G4EventManager &right)=delete
void	ProcessOneEvent (G4Event *anEvent)
void	ProcessOneEvent (G4TrackVector *trackVector, G4Event *anEvent=nullptr)
void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)
void	SetPrimaryTransformer (G4PrimaryTransformer *tf)
void	SetUserAction (G4UserEventAction *userAction)
void	SetUserAction (G4UserStackingAction *userAction)
void	SetUserAction (G4UserSteppingAction *userAction)
void	SetUserAction (G4UserTrackingAction *userAction)
void	SetUserInformation (G4VUserEventInformation *anInfo)
void	SetVerboseLevel (G4int value)
void	StackTracks (G4TrackVector *trackVector, G4bool IDhasAlreadySet=false)
void	StoreRandomNumberStatusToG4Event (G4int vl)
	~G4EventManager ()

Static Public Member Functions
static G4EventManager *	GetEventManager ()

Private Member Functions
void	DoProcessing (G4Event *anEvent)

Private Attributes
G4bool	abortRequested = false
G4Event *	currentEvent = nullptr
std::unique_ptr< ProfilerConfig >	eventProfiler
G4String	randomNumberStatusToG4Event
G4SDManager *	sdManager = nullptr
G4StateManager *	stateManager = nullptr
G4int	storetRandomNumberStatusToG4Event = 0
G4EvManMessenger *	theMessenger = nullptr
G4StackManager *	trackContainer = nullptr
G4int	trackIDCounter = 0
G4bool	tracking = false
G4TrackingManager *	trackManager = nullptr
G4TrajectoryContainer *	trajectoryContainer = nullptr
G4PrimaryTransformer *	transformer = nullptr
G4UserEventAction *	userEventAction = nullptr
G4UserStackingAction *	userStackingAction = nullptr
G4UserSteppingAction *	userSteppingAction = nullptr
G4UserTrackingAction *	userTrackingAction = nullptr
G4int	verboseLevel = 0

Static Private Attributes
static G4ThreadLocal G4EventManager *	fpEventManager = nullptr

Detailed Description

Definition at line 56 of file G4EventManager.hh.

Member Typedef Documentation

ProfilerConfig

using G4EventManager::ProfilerConfig = G4ProfilerConfig<G4ProfileType::Event>

Definition at line 59 of file G4EventManager.hh.

Constructor & Destructor Documentation

G4EventManager() [1/2]

G4EventManager::G4EventManager

(

)

Definition at line 57 of file G4EventManager.cc.

{
  if(fpEventManager != nullptr)
  {
    G4Exception("G4EventManager::G4EventManager", "Event0001", FatalException,
                "G4EventManager::G4EventManager() has already been made.");
  }
  else
  {
    trackManager = new G4TrackingManager;
    transformer = new G4PrimaryTransformer;
    trackContainer = new G4StackManager;
    theMessenger = new G4EvManMessenger(this);
    sdManager = G4SDManager::GetSDMpointerIfExist();
    stateManager = G4StateManager::GetStateManager();
    fpEventManager = this;
  }
}

References FatalException, fpEventManager, G4Exception(), G4SDManager::GetSDMpointerIfExist(), G4StateManager::GetStateManager(), sdManager, stateManager, theMessenger, trackContainer, trackManager, and transformer.

~G4EventManager()

G4EventManager::~G4EventManager

(

)

Definition at line 76 of file G4EventManager.cc.

{
  delete trackContainer;
  delete transformer;
  delete trackManager;
  delete theMessenger;
  delete userEventAction;
  fpEventManager = nullptr;
}

References fpEventManager, theMessenger, trackContainer, trackManager, transformer, and userEventAction.

G4EventManager() [2/2]

G4EventManager::G4EventManager ( const G4EventManager &  right )

delete

Member Function Documentation

AbortCurrentEvent()

void G4EventManager::AbortCurrentEvent

(

)

Definition at line 436 of file G4EventManager.cc.

{
  abortRequested = true;
  trackContainer->clear();
  if(tracking) trackManager->EventAborted();
}

References abortRequested, G4StackManager::clear(), G4TrackingManager::EventAborted(), trackContainer, tracking, and trackManager.

Referenced by G4RunManager::AbortEvent(), G4RunManager::AbortRun(), export_G4EventManager(), and G4EvManMessenger::SetNewValue().

DoProcessing()

void G4EventManager::DoProcessing ( G4Event *  anEvent )

private

Definition at line 86 of file G4EventManager.cc.

{
  abortRequested = false;
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_GeomClosed)
  {
    G4Exception("G4EventManager::ProcessOneEvent", "Event0002", JustWarning,
           "IllegalState -- Geometry not closed: cannot process an event.");
    return;
  }
  currentEvent = anEvent;
  stateManager->SetNewState(G4State_EventProc);
  if(storetRandomNumberStatusToG4Event > 1)
  {
    std::ostringstream oss;
    CLHEP::HepRandom::saveFullState(oss);
    randomNumberStatusToG4Event = oss.str();
    currentEvent->SetRandomNumberStatusForProcessing(randomNumberStatusToG4Event); 
  }
 
  // Resetting Navigator has been moved to G4EventManager,
  // so that resetting is now done for every event.
  G4ThreeVector center(0,0,0);
  G4Navigator* navigator = G4TransportationManager::GetTransportationManager()
                         ->GetNavigatorForTracking();
  navigator->LocateGlobalPointAndSetup(center,0,false);
                                                                                      
  G4Track* track = nullptr;
  G4TrackStatus istop = fAlive;
 
#ifdef G4VERBOSE
  if ( verboseLevel > 0 )
  {
    G4cout << "=====================================" << G4endl;
    G4cout << "  G4EventManager::ProcessOneEvent()  " << G4endl;
    G4cout << "=====================================" << G4endl;
  }
#endif
 
  trackContainer->PrepareNewEvent();
 
#ifdef G4_STORE_TRAJECTORY
  trajectoryContainer = nullptr;
#endif
 
  sdManager = G4SDManager::GetSDMpointerIfExist();
  if(sdManager != nullptr)
  { currentEvent->SetHCofThisEvent(sdManager->PrepareNewEvent()); }
 
  if(userEventAction) userEventAction->BeginOfEventAction(currentEvent);
 
#if defined(GEANT4_USE_TIMEMORY)
  eventProfiler.reset(new ProfilerConfig(currentEvent));
#endif
 
#ifdef G4VERBOSE
  if ( verboseLevel > 1 )
  {
    G4cout << currentEvent->GetNumberOfPrimaryVertex()
         << " vertices passed from G4Event." << G4endl;
  }
#endif
 
  if(!abortRequested)
  {
    StackTracks(transformer->GimmePrimaries(currentEvent,trackIDCounter), true);
  }
 
#ifdef G4VERBOSE
  if ( verboseLevel > 0 )
  {
    G4cout << trackContainer->GetNTotalTrack() << " primaries "
           << "are passed from G4EventTransformer." << G4endl;
    G4cout << "!!!!!!! Now start processing an event !!!!!!!" << G4endl;
  }
#endif
 
  std::unordered_set<G4VTrackingManager *> trackingManagersToFlush;
 
  do
  {
    G4VTrajectory* previousTrajectory;
    while( (track=trackContainer->PopNextTrack(&previousTrajectory)) != nullptr )
    {                                        // Loop checking 12.28.2015 M.Asai
 
      const G4ParticleDefinition* partDef = track->GetParticleDefinition();
      G4VTrackingManager* particleTrackingManager = partDef->GetTrackingManager();
 
      if (particleTrackingManager != nullptr)
      {
#ifdef G4VERBOSE
        if ( verboseLevel > 1 )
        {
          G4cout << "Track " << track << " (trackID " << track->GetTrackID()
                 << ", parentID " << track->GetParentID()
                 << ") is handed over to custom TrackingManager." << G4endl;
        }
#endif
 
        particleTrackingManager->HandOverOneTrack(track);
        // The particle's tracking manager may either track immediately or
        // defer processing until FlushEvent is called. Thus, we must neither
        // check the track's status nor stack secondaries.
 
        // Remember this tracking manager to later call FlushEvent.
        trackingManagersToFlush.insert(particleTrackingManager);
 
      } else {
#ifdef G4VERBOSE
        if ( verboseLevel > 1 )
        {
          G4cout << "Track " << track << " (trackID " << track->GetTrackID()
                 << ", parentID " << track->GetParentID()
                 << ") is passed to G4TrackingManager." << G4endl;
        }
#endif
 
        tracking = true;
        trackManager->ProcessOneTrack( track );
        istop = track->GetTrackStatus();
        tracking = false;
 
#ifdef G4VERBOSE
        if ( verboseLevel > 0 )
        {
          G4cout << "Track (trackID " << track->GetTrackID()
             << ", parentID " << track->GetParentID()
             << ") is processed with stopping code " << istop << G4endl;
        }
#endif
 
        G4VTrajectory* aTrajectory = nullptr;
#ifdef G4_STORE_TRAJECTORY
        aTrajectory = trackManager->GimmeTrajectory();
 
        if(previousTrajectory != nullptr)
        {
          previousTrajectory->MergeTrajectory(aTrajectory);
          delete aTrajectory;
          aTrajectory = previousTrajectory;
        }
        if(aTrajectory&&(istop!=fStopButAlive)&&(istop!=fSuspend))
        {
          if(trajectoryContainer == nullptr)
          {
            trajectoryContainer = new G4TrajectoryContainer;
            currentEvent->SetTrajectoryContainer(trajectoryContainer);
          }
          trajectoryContainer->insert(aTrajectory);
        }
#endif
 
        G4TrackVector* secondaries = trackManager->GimmeSecondaries();
        switch (istop)
        {
          case fStopButAlive:
          case fSuspend:
            trackContainer->PushOneTrack( track, aTrajectory );
            StackTracks( secondaries );
            break;
 
          case fPostponeToNextEvent:
            trackContainer->PushOneTrack( track );
            StackTracks( secondaries );
            break;
 
          case fStopAndKill:
            StackTracks( secondaries );
            delete track;
            break;
 
          case fAlive:
            G4Exception("G4EventManager::DoProcessing", "Event004", JustWarning,
                "Illegal trackstatus returned from G4TrackingManager."\
                " Continue with simulation.");
            break;
          case fKillTrackAndSecondaries:
            if( secondaries )
            {
              for(std::size_t i=0; i<secondaries->size(); ++i)
              { delete (*secondaries)[i]; }
              secondaries->clear();
            }
            delete track;
            break;
        }
      }
    }
 
    // Flush all tracking managers, which may have deferred processing until now.
    for (G4VTrackingManager *tm : trackingManagersToFlush)
    {
      tm->FlushEvent();
    }
    trackingManagersToFlush.clear();
 
    // Check if flushing one of the tracking managers stacked new secondaries.
  } while (trackContainer->GetNUrgentTrack() > 0);
 
#ifdef G4VERBOSE
  if ( verboseLevel > 0 )
  {
    G4cout << "NULL returned from G4StackManager." << G4endl;
    G4cout << "Terminate current event processing." << G4endl;
  }
#endif
 
  if(sdManager != nullptr)
  {
    sdManager->TerminateCurrentEvent(currentEvent->GetHCofThisEvent());
  }
 
#if defined(GEANT4_USE_TIMEMORY)
  eventProfiler.reset();
#endif
 
  if(userEventAction)
  {
    userEventAction->EndOfEventAction(currentEvent);
  }
 
  stateManager->SetNewState(G4State_GeomClosed);
  currentEvent = nullptr;
  abortRequested = false;
}

References abortRequested, G4UserEventAction::BeginOfEventAction(), currentEvent, G4UserEventAction::EndOfEventAction(), eventProfiler, fAlive, fKillTrackAndSecondaries, fPostponeToNextEvent, fStopAndKill, fStopButAlive, fSuspend, G4cout, G4endl, G4Exception(), G4State_EventProc, G4State_GeomClosed, G4StateManager::GetCurrentState(), G4Event::GetHCofThisEvent(), G4TransportationManager::GetNavigatorForTracking(), G4StackManager::GetNTotalTrack(), G4Event::GetNumberOfPrimaryVertex(), G4StackManager::GetNUrgentTrack(), G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4SDManager::GetSDMpointerIfExist(), G4Track::GetTrackID(), G4ParticleDefinition::GetTrackingManager(), G4Track::GetTrackStatus(), G4TransportationManager::GetTransportationManager(), G4PrimaryTransformer::GimmePrimaries(), G4TrackingManager::GimmeSecondaries(), G4TrackingManager::GimmeTrajectory(), G4VTrackingManager::HandOverOneTrack(), G4TrajectoryContainer::insert(), JustWarning, G4VTrajectory::MergeTrajectory(), write_gdml::navigator, G4StackManager::PopNextTrack(), G4SDManager::PrepareNewEvent(), G4StackManager::PrepareNewEvent(), G4TrackingManager::ProcessOneTrack(), G4StackManager::PushOneTrack(), randomNumberStatusToG4Event, CLHEP::HepRandom::saveFullState(), sdManager, G4Event::SetHCofThisEvent(), G4StateManager::SetNewState(), G4Event::SetRandomNumberStatusForProcessing(), G4Event::SetTrajectoryContainer(), StackTracks(), stateManager, storetRandomNumberStatusToG4Event, G4SDManager::TerminateCurrentEvent(), G4InuclParticleNames::tm, trackContainer, trackIDCounter, tracking, trackManager, trajectoryContainer, transformer, userEventAction, and verboseLevel.

Referenced by ProcessOneEvent().

GetConstCurrentEvent()

const G4Event * G4EventManager::GetConstCurrentEvent ( )

inline

Definition at line 95 of file G4EventManager.hh.

      { return currentEvent; }

References currentEvent.

Referenced by G4VisManager::Draw(), G4VisManager::EndOfEvent(), and export_G4EventManager().

GetEventManager()

G4EventManager * G4EventManager::GetEventManager ( )

static

Definition at line 52 of file G4EventManager.cc.

{
  return fpEventManager;
}

References fpEventManager.

Referenced by G4StackChecker::ClassifyNewTrack(), G4VisManager::Draw(), G4VisManager::EndOfEvent(), export_G4EventManager(), G4ErrorPropagator::G4ErrorPropagator(), G4MaterialScanner::G4MaterialScanner(), G4TheRayTracer::G4TheRayTracer(), G4ErrorPropagator::InvokePostUserTrackingAction(), G4ErrorPropagator::InvokePreUserTrackingAction(), G4ErrorPropagatorManager::SetSteppingManagerVerboseLevel(), G4ErrorPropagatorManager::SetUserAction(), G4ErrorRunManagerHelper::SetUserAction(), and G4ErrorPropagatorManager::StartNavigator().

GetNonconstCurrentEvent()

G4Event * G4EventManager::GetNonconstCurrentEvent ( )

inline

Definition at line 97 of file G4EventManager.hh.

      { return currentEvent; }

References currentEvent.

Referenced by export_G4EventManager().

GetPrimaryTransformer()

G4PrimaryTransformer * G4EventManager::GetPrimaryTransformer ( ) const

inline

Definition at line 153 of file G4EventManager.hh.

      { return transformer; }

References transformer.

Referenced by G4RunManagerKernel::GetPrimaryTransformer().

GetStackManager()

G4StackManager * G4EventManager::GetStackManager ( ) const

inline

Definition at line 132 of file G4EventManager.hh.

      { return trackContainer; }

References trackContainer.

Referenced by export_G4EventManager(), and G4RunManagerKernel::GetStackManager().

GetTrackingManager()

G4TrackingManager * G4EventManager::GetTrackingManager ( ) const

inline

Definition at line 134 of file G4EventManager.hh.

      { return trackManager; }

References trackManager.

Referenced by export_G4EventManager(), G4ErrorPropagator::G4ErrorPropagator(), G4RunManagerKernel::GetTrackingManager(), G4ErrorPropagatorManager::SetSteppingManagerVerboseLevel(), and G4ErrorPropagatorManager::StartNavigator().

GetUserEventAction()

G4UserEventAction * G4EventManager::GetUserEventAction ( )

inline

Definition at line 113 of file G4EventManager.hh.

      { return userEventAction; }

References userEventAction.

Referenced by G4MaterialScanner::StoreUserActions(), and G4TheRayTracer::StoreUserActions().

GetUserInformation()

G4VUserEventInformation * G4EventManager::GetUserInformation

(

)

Definition at line 420 of file G4EventManager.cc.

{ 
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_EventProc || currentEvent == 0)
  {
    return nullptr;
  }
  
  return currentEvent->GetUserInformation();
}

References currentEvent, G4State_EventProc, G4StateManager::GetCurrentState(), G4Event::GetUserInformation(), and stateManager.

Referenced by export_G4EventManager().

GetUserStackingAction()

G4UserStackingAction * G4EventManager::GetUserStackingAction ( )

inline

Definition at line 115 of file G4EventManager.hh.

      { return userStackingAction; }

References userStackingAction.

Referenced by G4MaterialScanner::StoreUserActions(), and G4TheRayTracer::StoreUserActions().

GetUserSteppingAction()

G4UserSteppingAction * G4EventManager::GetUserSteppingAction ( )

inline

Definition at line 119 of file G4EventManager.hh.

      { return userSteppingAction; }

References userSteppingAction.

Referenced by G4MaterialScanner::StoreUserActions(), and G4TheRayTracer::StoreUserActions().

GetUserTrackingAction()

G4UserTrackingAction * G4EventManager::GetUserTrackingAction ( )

inline

Definition at line 117 of file G4EventManager.hh.

      { return userTrackingAction; }

References userTrackingAction.

Referenced by G4ErrorPropagator::InvokePostUserTrackingAction(), G4ErrorPropagator::InvokePreUserTrackingAction(), G4MaterialScanner::StoreUserActions(), and G4TheRayTracer::StoreUserActions().

GetVerboseLevel()

G4int G4EventManager::GetVerboseLevel ( )

inline

Definition at line 137 of file G4EventManager.hh.

      { return verboseLevel; }

References verboseLevel.

Referenced by export_G4EventManager(), and G4EvManMessenger::GetCurrentValue().

KeepTheCurrentEvent()

void G4EventManager::KeepTheCurrentEvent

(

)

Definition at line 431 of file G4EventManager.cc.

{
  if(currentEvent != nullptr)  { currentEvent->KeepTheEvent(); }
}

References currentEvent, and G4Event::KeepTheEvent().

Referenced by G4VisManager::EndOfEvent(), and G4EvManMessenger::SetNewValue().

operator=()

G4EventManager & G4EventManager::operator= ( const G4EventManager &  right )

delete

ProcessOneEvent() [1/2]

void G4EventManager::ProcessOneEvent

(

G4Event *

anEvent

)

Definition at line 374 of file G4EventManager.cc.

{
  trackIDCounter = 0;
  DoProcessing(anEvent);
}

References DoProcessing(), and trackIDCounter.

Referenced by G4TheRayTracer::CreateBitMap(), G4MaterialScanner::DoScan(), G4RunManager::ProcessOneEvent(), G4WorkerRunManager::ProcessOneEvent(), and G4WorkerTaskRunManager::ProcessOneEvent().

ProcessOneEvent() [2/2]

void G4EventManager::ProcessOneEvent	(	G4TrackVector *	trackVector,
		G4Event *	anEvent = nullptr
	)

Definition at line 380 of file G4EventManager.cc.

{
  static G4ThreadLocal G4String* randStat = nullptr;
  if (randStat == nullptr) randStat = new G4String;
  trackIDCounter = 0;
  G4bool tempEvent = false;
  if(anEvent == nullptr)
  {
    anEvent = new G4Event();
    tempEvent = true;
  }
  if (storetRandomNumberStatusToG4Event==1
   || storetRandomNumberStatusToG4Event==3)
  {
    std::ostringstream oss;
    CLHEP::HepRandom::saveFullState(oss);
    (*randStat) = oss.str();
    anEvent->SetRandomNumberStatus(*randStat);
  }
  StackTracks(trackVector,false);
  DoProcessing(anEvent);
  if(tempEvent) { delete anEvent; }
}

References DoProcessing(), G4ThreadLocal, CLHEP::HepRandom::saveFullState(), G4Event::SetRandomNumberStatus(), StackTracks(), storetRandomNumberStatusToG4Event, and trackIDCounter.

SetNumberOfAdditionalWaitingStacks()

void G4EventManager::SetNumberOfAdditionalWaitingStacks ( G4int  iAdd )

inline

Definition at line 125 of file G4EventManager.hh.

      { trackContainer->SetNumberOfAdditionalWaitingStacks(iAdd); }

References G4StackManager::SetNumberOfAdditionalWaitingStacks(), and trackContainer.

Referenced by export_G4EventManager(), and G4RunManager::SetNumberOfAdditionalWaitingStacks().

SetPrimaryTransformer()

void G4EventManager::SetPrimaryTransformer ( G4PrimaryTransformer *  tf )

inline

Definition at line 155 of file G4EventManager.hh.

      { transformer = tf; }

References transformer.

Referenced by G4RunManagerKernel::SetPrimaryTransformer().

SetUserAction() [1/4]

void G4EventManager::SetUserAction

(

G4UserEventAction *

userAction

)

Definition at line 347 of file G4EventManager.cc.

{
  userEventAction = userAction;
  if(userEventAction != nullptr)
  {
    userEventAction->SetEventManager(this);
  }
}

References G4UserEventAction::SetEventManager(), and userEventAction.

Referenced by G4MaterialScanner::RestoreUserActions(), G4TheRayTracer::RestoreUserActions(), G4RunManager::SetUserAction(), G4ErrorPropagatorManager::SetUserAction(), G4ErrorRunManagerHelper::SetUserAction(), G4MaterialScanner::StoreUserActions(), and G4TheRayTracer::StoreUserActions().

SetUserAction() [2/4]

void G4EventManager::SetUserAction

(

G4UserStackingAction *

userAction

)

Definition at line 356 of file G4EventManager.cc.

{
  userStackingAction = userAction;
  trackContainer->SetUserStackingAction(userAction);
}

References G4StackManager::SetUserStackingAction(), trackContainer, and userStackingAction.

SetUserAction() [3/4]

void G4EventManager::SetUserAction

(

G4UserSteppingAction *

userAction

)

Definition at line 368 of file G4EventManager.cc.

{
  userSteppingAction = userAction;
  trackManager->SetUserAction(userAction);
}

References G4TrackingManager::SetUserAction(), trackManager, and userSteppingAction.

SetUserAction() [4/4]

void G4EventManager::SetUserAction

(

G4UserTrackingAction *

userAction

)

Definition at line 362 of file G4EventManager.cc.

{
  userTrackingAction = userAction;
  trackManager->SetUserAction(userAction);
}

References G4TrackingManager::SetUserAction(), trackManager, and userTrackingAction.

SetUserInformation()

void G4EventManager::SetUserInformation

(

G4VUserEventInformation *

anInfo

)

Definition at line 405 of file G4EventManager.cc.

{ 
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(currentState != G4State_EventProc || currentEvent == 0)
  {
    G4Exception("G4EventManager::SetUserInformation",
                "Event0003", JustWarning,
                "G4VUserEventInformation cannot be set because of absence "\
                "of G4Event.");
    return;
  }
  
  currentEvent->SetUserInformation(anInfo);
}

References currentEvent, G4Exception(), G4State_EventProc, G4StateManager::GetCurrentState(), JustWarning, G4Event::SetUserInformation(), and stateManager.

Referenced by export_G4EventManager().

SetVerboseLevel()

void G4EventManager::SetVerboseLevel ( G4int  value )

inline

Definition at line 139 of file G4EventManager.hh.

      {
        verboseLevel = value;
        trackContainer->SetVerboseLevel( value );
        transformer->SetVerboseLevel( value );
      }

References G4StackManager::SetVerboseLevel(), G4PrimaryTransformer::SetVerboseLevel(), trackContainer, transformer, and verboseLevel.

Referenced by export_G4EventManager(), and G4EvManMessenger::SetNewValue().

StackTracks()

void G4EventManager::StackTracks	(	G4TrackVector *	trackVector,
		G4bool	IDhasAlreadySet = false
	)

Definition at line 312 of file G4EventManager.cc.

{
  if( trackVector != nullptr )
  {
    if( trackVector->size() == 0 ) return;
    for( auto newTrack : *trackVector )
    {
      ++trackIDCounter;
      if(!IDhasAlreadySet)
      {
        newTrack->SetTrackID( trackIDCounter );
        if(newTrack->GetDynamicParticle()->GetPrimaryParticle())
        {
          G4PrimaryParticle* pp
            = (G4PrimaryParticle*)(newTrack->GetDynamicParticle()->GetPrimaryParticle());
          pp->SetTrackID(trackIDCounter);
        }
      }
      newTrack->SetOriginTouchableHandle(newTrack->GetTouchableHandle());
      trackContainer->PushOneTrack( newTrack );
#ifdef G4VERBOSE
      if ( verboseLevel > 1 )
      {
        G4cout << "A new track " << newTrack 
               << " (trackID " << newTrack->GetTrackID()
               << ", parentID " << newTrack->GetParentID() 
               << ") is passed to G4StackManager." << G4endl;
      }
#endif
    }
    trackVector->clear();
  }
}

References G4cout, G4endl, G4InuclParticleNames::pp, G4StackManager::PushOneTrack(), trackContainer, trackIDCounter, and verboseLevel.

Referenced by DoProcessing(), and ProcessOneEvent().

StoreRandomNumberStatusToG4Event()

void G4EventManager::StoreRandomNumberStatusToG4Event ( G4int  vl )

inline

Definition at line 157 of file G4EventManager.hh.

      { storetRandomNumberStatusToG4Event = vl; }

References storetRandomNumberStatusToG4Event.

Referenced by G4RunManager::StoreRandomNumberStatusToG4Event().

Field Documentation

abortRequested

G4bool G4EventManager::abortRequested = false

private

Definition at line 178 of file G4EventManager.hh.

Referenced by AbortCurrentEvent(), and DoProcessing().

currentEvent

G4Event* G4EventManager::currentEvent = nullptr

private

Definition at line 168 of file G4EventManager.hh.

Referenced by DoProcessing(), GetConstCurrentEvent(), GetNonconstCurrentEvent(), GetUserInformation(), KeepTheCurrentEvent(), and SetUserInformation().

eventProfiler

std::unique_ptr<ProfilerConfig> G4EventManager::eventProfiler

private

Definition at line 193 of file G4EventManager.hh.

Referenced by DoProcessing().

fpEventManager

G4ThreadLocal G4EventManager * G4EventManager::fpEventManager = nullptr

staticprivate

Definition at line 166 of file G4EventManager.hh.

Referenced by G4EventManager(), GetEventManager(), and ~G4EventManager().

randomNumberStatusToG4Event

G4String G4EventManager::randomNumberStatusToG4Event

private

Definition at line 188 of file G4EventManager.hh.

Referenced by DoProcessing().

sdManager

G4SDManager* G4EventManager::sdManager = nullptr

private

Definition at line 175 of file G4EventManager.hh.

Referenced by DoProcessing(), and G4EventManager().

stateManager

G4StateManager* G4EventManager::stateManager = nullptr

private

Definition at line 190 of file G4EventManager.hh.

Referenced by DoProcessing(), G4EventManager(), GetUserInformation(), and SetUserInformation().

storetRandomNumberStatusToG4Event

G4int G4EventManager::storetRandomNumberStatusToG4Event = 0

private

Definition at line 187 of file G4EventManager.hh.

Referenced by DoProcessing(), ProcessOneEvent(), and StoreRandomNumberStatusToG4Event().

theMessenger

G4EvManMessenger* G4EventManager::theMessenger = nullptr

private

Definition at line 180 of file G4EventManager.hh.

Referenced by G4EventManager(), and ~G4EventManager().

trackContainer

G4StackManager* G4EventManager::trackContainer = nullptr

private

Definition at line 170 of file G4EventManager.hh.

Referenced by AbortCurrentEvent(), DoProcessing(), G4EventManager(), GetStackManager(), SetNumberOfAdditionalWaitingStacks(), SetUserAction(), SetVerboseLevel(), StackTracks(), and ~G4EventManager().

trackIDCounter

G4int G4EventManager::trackIDCounter = 0

private

Definition at line 173 of file G4EventManager.hh.

Referenced by DoProcessing(), ProcessOneEvent(), and StackTracks().

tracking

G4bool G4EventManager::tracking = false

private

Definition at line 177 of file G4EventManager.hh.

Referenced by AbortCurrentEvent(), and DoProcessing().

trackManager

G4TrackingManager* G4EventManager::trackManager = nullptr

private

Definition at line 171 of file G4EventManager.hh.

Referenced by AbortCurrentEvent(), DoProcessing(), G4EventManager(), GetTrackingManager(), SetUserAction(), and ~G4EventManager().

trajectoryContainer

G4TrajectoryContainer* G4EventManager::trajectoryContainer = nullptr

private

Definition at line 172 of file G4EventManager.hh.

Referenced by DoProcessing().

transformer

G4PrimaryTransformer* G4EventManager::transformer = nullptr

private

Definition at line 176 of file G4EventManager.hh.

Referenced by DoProcessing(), G4EventManager(), GetPrimaryTransformer(), SetPrimaryTransformer(), SetVerboseLevel(), and ~G4EventManager().

userEventAction

G4UserEventAction* G4EventManager::userEventAction = nullptr

private

Definition at line 182 of file G4EventManager.hh.

Referenced by DoProcessing(), GetUserEventAction(), SetUserAction(), and ~G4EventManager().

userStackingAction

G4UserStackingAction* G4EventManager::userStackingAction = nullptr

private

Definition at line 183 of file G4EventManager.hh.

Referenced by GetUserStackingAction(), and SetUserAction().

userSteppingAction

G4UserSteppingAction* G4EventManager::userSteppingAction = nullptr

private

Definition at line 185 of file G4EventManager.hh.

Referenced by GetUserSteppingAction(), and SetUserAction().

userTrackingAction

G4UserTrackingAction* G4EventManager::userTrackingAction = nullptr

private

Definition at line 184 of file G4EventManager.hh.

Referenced by GetUserTrackingAction(), and SetUserAction().

verboseLevel

G4int G4EventManager::verboseLevel = 0

private

Definition at line 174 of file G4EventManager.hh.

Referenced by DoProcessing(), GetVerboseLevel(), SetVerboseLevel(), and StackTracks().

---

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

• source/event/include/G4EventManager.hh
• source/event/src/G4EventManager.cc