A run manager for GGS simulations. More...

#include <GGSRunManager.h>

Inheritance diagram for GGSRunManager:

Collaboration diagram for GGSRunManager:

Public Member Functions
	GGSRunManager ()
	Constructor.

	~GGSRunManager ()
	Destructor.

void	DoEventLoop (G4int n_event, const char *macroFile, G4int n_select)
	Override of G4RunManager::DoEventLoop. More...

void	SetGGSGeneratorAction (G4VUserPrimaryGeneratorAction *userAction)
	Replacement of the SetUserAction method. More...

void	PrintLogVols ()
	Print a list of logical volumes in current geometries.

int	GetNDiscardedEvents ()
	Getter method for number of discarded events. More...

int	GetNKilledEvents ()
	Getter method for number of killed events. More...

void	KillEvent ()
	Kills the current event. More...

void	SimulateAgainKilledEvent ()
	Simulates again a killed event. More...

bool	IsCurrentEventKilled ()
	Getter method for killed event flag. More...

const long int *	GetRandomSeedsAtBeginOfEvent ()
	Getter methos for random seeds at the beginning of the current event. More...

Static Public Member Functions
static GGSRunManager *	GetRunManager ()
	Static getter function the run manager. More...

Detailed Description

A run manager for GGS simulations.

This class inherits from G4RunManager and adds some GGS-specific features.

Definition at line 23 of file GGSRunManager.h.

Member Function Documentation

void GGSRunManager::DoEventLoop	(	G4int	n_event,
		const char *	macroFile,
		G4int	n_select
	)

Override of G4RunManager::DoEventLoop.

This override adds the possibility of re-generate and re-simulate a killed event when the killer routine calls #RedoKilled. No other change is made with respect to G4RunManager::DoEventLoop.

Parameters

n_event
macroFile
n_select

Definition at line 53 of file GGSRunManager.cpp.

                                                                                     {
   static const std::string routineName("GGSRunManager::DoEventLoop");
   InitializeEventLoop(n_event, macroFile, n_select);
   _isCurrEvKilled = false;
   _simAgainKilledEv = false;
   _nKilledEvs = 0;
 
   // Event loop
   for (G4int i_event = 0; i_event < n_event; i_event++) {
     // Store random seeds at begin of event
     _currEvSeeds[0] = CLHEP::HepRandom::getTheSeeds()[0];
     _currEvSeeds[1] = CLHEP::HepRandom::getTheSeeds()[1];
 
     ProcessOneEvent(i_event);
     TerminateOneEvent();
     if (runAborted)
       break;
 
     // Check if the event has been killed
     if (_isCurrEvKilled) {
       COUT(DEEPDEB) << "Event " << i_event << " has been killed. " << ENDL;
       if (_ggsGeneratorAction) {
         CCOUT(DEEPDEB) << "Discarded at generation: " << _ggsGeneratorAction->GetNDiscarded()
                        << " (total: " << _nDiscardedEvsInKilledEvs << ")" << ENDL;
       }
       if (_simAgainKilledEv) {
         i_event--;
         CCOUT(DEEPDEB) << "Will be simulated again." << ENDL;
       }
     } else {
       COUT(DEEPDEB) << "Finished simulating event " << i_event << ENDL;
       if (_ggsGeneratorAction) {
         CCOUT(DEEPDEB) << "Discarded at generation: " << _ggsGeneratorAction->GetNDiscarded()
                        << " (total: " << GetNDiscardedEvents() << ")" << ENDL;
       }
       CCOUT(DEEPDEB) << "Killed: " << _nKilledEvs << ENDL;
       // Reset discarded and killed event counters
       _nDiscardedEvsInKilledEvs = 0;
       _nKilledEvs = 0;
       if (_simAgainKilledEv) {
         static bool printDone = false;
         if (!printDone) {
           COUT(WARNING) << "Request to re-simulate an event which has not been flagged as killed. Ignoring." << ENDL;
           CCOUT(WARNING) << "This message will be printed only once." << ENDL;
           printDone = true;
         }
       }
     }
     _isCurrEvKilled = false;
     _simAgainKilledEv = false;
   }
 
   TerminateEventLoop();
 }

int GGSRunManager::GetNDiscardedEvents ( )

inline

Getter method for number of discarded events.

This method returns the number of discarded events. Discarded events are events which are generated but not simulated because they do not fulfill the acceptance criterion defined by the geometry. The counter is reset every time an event is successfully generated inside acceptance and simulated (i.e. not killed). This method will always return 0 if the particle generator does not inherit from GGSGeneratorAction.

Returns: The number of discarded events since the last simulated one.

Definition at line 85 of file GGSRunManager.h.

                             {
     if (_ggsGeneratorAction)
       return _nDiscardedEvsInKilledEvs + _ggsGeneratorAction->GetNDiscarded();
     return 0;
   }

int GGSRunManager::GetNKilledEvents ( )

inline

Getter method for number of killed events.

This method returns the number of killed events since the last non-killed one.

Returns: The number of killed events since the last non-killed one.

Definition at line 98 of file GGSRunManager.h.

98 { return _nKilledEvs; }

const long int* GGSRunManager::GetRandomSeedsAtBeginOfEvent ( )

inline

Getter methos for random seeds at the beginning of the current event.

Returns: a long int array with the two seeds;

Definition at line 135 of file GGSRunManager.h.

135 { return _currEvSeeds; }

GGSRunManager * GGSRunManager::GetRunManager ( )

static

Static getter function the run manager.

Returns: Pointer to the GGS run manager.

Definition at line 22 of file GGSRunManager.cpp.

                                             {
   if (!_runManager) {
     G4Exception("GGSRunManager::GetRunManager()", "GGS", FatalException, "GGSRunManager not yet constructed.");
   }
   return _runManager;
 }

bool GGSRunManager::IsCurrentEventKilled ( )

Getter method for killed event flag.

This method returns true if SetEventAsKilled has been called during current event.

Returns: true if the current event has been killed

Definition at line 140 of file GGSRunManager.cpp.

140 { return _isCurrEvKilled; }

void GGSRunManager::KillEvent ( )

Kills the current event.

This method can be called by user actions to kill an event. The difference between this method and G4EventManager::AbortCurrentEvent is that calling KillEvent and then SimulateAgainKilledEvent it is possible to simulate a new event without increasing the number of simulated events. In other words, when using KillEvent and SimulateAgainKilledEvent killed events won't contribute to the count of total simulated events.

See Also: SimulateAgainKilledEvent; GetNKilledEvents

Definition at line 122 of file GGSRunManager.cpp.

                               {
   static const std::string routineName("GGSRunManager::KillEvent");
   if (!_isCurrEvKilled) {
     COUT(DEEPDEB) << "Kill event" << std::endl;
     G4EventManager::GetEventManager()->AbortCurrentEvent();
     _isCurrEvKilled = true;
     _nKilledEvs++;
     if (_ggsGeneratorAction)
       _nDiscardedEvsInKilledEvs += _ggsGeneratorAction->GetNDiscarded();
   }
 }

void GGSRunManager::SetGGSGeneratorAction ( G4VUserPrimaryGeneratorAction * userAction )

inline

Replacement of the SetUserAction method.

This version checks whether the generator action inherits from GGSGeneratorAction and then registers it in the parent G4RunManager. The GGSGeneratorAction can then be retrieved by means of the GetGGSGeneratorAction method.

Note: use this method to register a generator action inheriting from GGSGeneratorAction (instead of the standard SetUserAction method) to take advantage of the mechanism to avoid dynamic_cast described in GetGGSGeneratorAction; that mechanism will not work if SetUserAction is used to register the generator action in the run manager, but all other functionalities will not be affected.

Parameters

userAction The user defined primary generator action.

Definition at line 65 of file GGSRunManager.h.

                                                                         {
     _ggsGeneratorAction = dynamic_cast<GGSGeneratorAction *>(userAction);
     G4RunManager::SetUserAction(userAction);
   }

void GGSRunManager::SimulateAgainKilledEvent ( )

Simulates again a killed event.

This method must be called by user actions after killing an event if the killed event has to be re-generated and re-simulated. The method #SetEventAsKilled must be called before, in order to enable re-generation and simulation, otherwise a warning message is displayed and the event is not re-generated and simulated.

Definition at line 136 of file GGSRunManager.cpp.

136 { _simAgainKilledEv = true; }

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

Public Member Functions

Static Public Member Functions

Detailed Description

Member Function Documentation