GGSRunManagerExtensions Class Reference

Class with additional functionalities for run managers. More...

#include <GGSRunManagerExtensions.h>

Inheritance diagram for GGSRunManagerExtensions:

Public Member Functions
	GGSRunManagerExtensions ()
	Constructor.
virtual	~GGSRunManagerExtensions ()=default
	Destructor. 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 std::string &	GetRandomStateAtBeginOfEvent ()
	Getter method for random engine state at the beginning of the current event. More...
void	SetGGSGeneratorAction (G4VUserPrimaryGeneratorAction *userAction)
	Replacement of the SetUserAction method. More...
int	GetNDiscardedEvents ()
	Getter method for number of discarded events. More...
const std::string &	RngStateRestoredFrom ()
	The random engine state file for this event. More...

Protected Member Functions
void	BeginOfEventProcessing ()
	Method for storing the random engine state and resetting the internal flags at the beginning event generation. More...
void	BeginOfEventSimulation ()
	Reset the internal flags at the beginning of event simulation. More...
void	DumpStatus (G4int eventID)
	Prints the status of the random number generator. More...
bool	IsKilledAndToBeSimulatedAgain (const G4Event *ev)
	Checks if the event has been killed and has to be re-simulated. More...
void	PrintLogVols ()
	Print a list of logical volumes in current geometries.
void	HandleEventRngStateFile (int runID, int eventID)
	Handles the read/write operations to/from the random generator state file for each event. More...

Detailed Description

Class with additional functionalities for run managers.

This class is meant to be used to extend the interfaces of standard G4 run managers with additional GGS functionalities. The class has a virtual destructor to make it possible to obtain the GGSRunManagerExtensions interface from a a G4RunManager pointer with a dynamic_cast.

Definition at line 28 of file GGSRunManagerExtensions.h.

Constructor & Destructor Documentation

virtual GGSRunManagerExtensions::~GGSRunManagerExtensions ( )

virtualdefault

Destructor.

Declared only to make it possible to recover the GGSRunManagerExtensions interface from a G4RunManager pointer.

Member Function Documentation

void GGSRunManagerExtensions::BeginOfEventProcessing ( )

protected

Method for storing the random engine state and resetting the internal flags at the beginning event generation.

To be called in derived classes before generating the event, i.e. before calling the GenerateEvent method of the run manager class. Do not call again if the primaries are re-generated.

Definition at line 47 of file GGSRunManagerExtensions.cpp.

                                                     {
  std::stringstream buffer;
  G4Random::getTheEngine()->put(buffer);
  _stateAtBeginOfEvent = std::move(buffer.str());
  _nKilledEvs = 0;
}

void GGSRunManagerExtensions::BeginOfEventSimulation ( )

protected

Reset the internal flags at the beginning of event simulation.

To be called in derived classes before starting to process an event, i.e. before calling G4EventManager::ProcessOneEvent.

Definition at line 54 of file GGSRunManagerExtensions.cpp.

                                                     {
  _isCurrEvKilled = false;
  _simAgainKilledEv = false;
}

void GGSRunManagerExtensions::DumpStatus ( G4int  eventID )

protected

Prints the status of the random number generator.

To be called after generating the event and before starting to simulate it

Parameters

eventID

The ID of the event

Definition at line 59 of file GGSRunManagerExtensions.cpp.

                                                      {
  auto Indent = [](const std::string &str) {
    std::string indentedStr;
    size_t pos = 0;
    while (true) {
      auto newlinePos = str.find_first_of('\n', pos);
      if (newlinePos != std::string::npos) {
        indentedStr.append("   ").append(str, pos, newlinePos - pos + 1);
        pos = newlinePos + 1;
      } else {
        break;
      }
    }
    return indentedStr;
  };

  if (_printModulo != 0) {
    if (eventID % _printModulo == 0 && eventID > _lastPrinted) {
      std::stringstream outSS, bufferSS;
      outSS << "---> Begin of event: " << eventID << "\n";
      outSS << "--------- " << G4Random::getTheEngine()->name() << " random engine state ---------\n";
      if (RngStateRestoredFrom() != "") {
        outSS << "--- Restored from: " << RngStateRestoredFrom() << "\n";
      }
      outSS << " State at begin of event generation:\n" << Indent(GetRandomStateAtBeginOfEvent()) << "\n";
      outSS << " State at begin of event tracking: \n";
      G4Random::getTheEngine()->put(bufferSS);
      outSS << Indent(bufferSS.str());
      outSS << "----------------------------------------\n";
      G4cout << outSS.str() << G4endl;
      _lastPrinted = eventID;
    }
  }
}

int GGSRunManagerExtensions::GetNDiscardedEvents

(

)

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 136 of file GGSRunManagerExtensions.cpp.

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

int GGSRunManagerExtensions::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 46 of file GGSRunManagerExtensions.h.

{ return _nKilledEvs; }

const std::string& GGSRunManagerExtensions::GetRandomStateAtBeginOfEvent ( )

inline

Getter method for random engine state at the beginning of the current event.

Returns

an array with the numbers defining the engine state.

Definition at line 83 of file GGSRunManagerExtensions.h.

{ return _stateAtBeginOfEvent; }

void GGSRunManagerExtensions::HandleEventRngStateFile ( int  runID, int  eventID  )

protected

Handles the read/write operations to/from the random generator state file for each event.

This routine reads and writes the random generator state files for each event, effectively restoring the state from file or dumping the current state to file. Read and write behavior can be toggled by the /GGS/random/saveEventRngStateToFile and /GGS/random/readEventRngStateFromFile datacard commands (notice that when reading from file is enabled then dumping to file will be automatically disabled). The path and base file name can be set by means of /GGS/random/eventRngStateFilePath and /GGS/random/eventRngStateFileBase, respectively. The effective file name for each event is built by appending the run::evt#.rndm suffix to the base name, and then using the path to obtain the absolute file name.

If the file format is bad then a fatal G4Exception is thrown.

Parameters

runID	The ID of the current run.
eventID	The ID of the current event.

Definition at line 153 of file GGSRunManagerExtensions.cpp.

                                                                            {
  _restoredFrom = "";
  if (_saveEventRngStateToFile || _readEventRngStateFromFile) {

    const std::string fileName = _eventRandomFilePath + _eventRandomFileBase + "run" + std::to_string(runID) + "evt" +
                                 std::to_string(eventID) + ".rndm";

    if (_readEventRngStateFromFile) {
      // The different concrete random engines implement error handling in get() differently: some simply print a
      // message on cerr, some others throw exceptions. Handle this redirecting cerr to a dummy buffer before calling
      // get() and then check if it's empty or not (other than the usual try-catch block for eventual exceptions).
      std::stringstream cerrDummyBuf;
      std::streambuf *cerrBuf = std::cerr.rdbuf();
      std::cerr.rdbuf(cerrDummyBuf.rdbuf());
      std::ifstream stateFile(fileName);
      if (stateFile) { // File valid and readable
        bool error = false;
        std::string errorMessage;
        try {
          G4Random::getTheEngine()->get(stateFile);
          std::cerr.rdbuf(cerrBuf);
          if (cerrDummyBuf.str() != "") {
            error = true;
            errorMessage = cerrDummyBuf.str();
          }
        } catch (std::exception &exc) {
          error = true;
          errorMessage = exc.what();
        } catch (...) {
          error = true;
          errorMessage = "unknown";
        }
        if (error) {
          G4Exception("GGSRunManagerExtensions::HandleEventRngStateFile", "Can't read state file",
                      G4ExceptionSeverity::FatalException,
                      (("Error when restoring the state of the random engine from file ") + fileName +
                       "\nReason: " + errorMessage)
                          .c_str());
        } else {
          _restoredFrom = fileName;
        }
      } else {
        G4Exception("GGSRunManagerExtensions::HandleEventRngStateFile", "Missing state file",
                    G4ExceptionSeverity::FatalException,
                    (("Can't find the random engine state file ") + fileName).c_str());
      }
    }

    if (_saveEventRngStateToFile && !_readEventRngStateFromFile) { // If reading from file, avoid to rewrite the same
      std::ofstream stateFile(fileName);
      G4Random::getTheEngine()->put(stateFile);
    }
  }
}

bool GGSRunManagerExtensions::IsCurrentEventKilled ( )

inline

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 77 of file GGSRunManagerExtensions.h.

{ return _isCurrEvKilled; };

bool GGSRunManagerExtensions::IsKilledAndToBeSimulatedAgain ( const G4Event *  ev )

protected

Checks if the event has been killed and has to be re-simulated.

Parameters

ev	the current event.

Returns

true if the event has been killed and has to be simulated again.

Definition at line 94 of file GGSRunManagerExtensions.cpp.

                                                                             {
  static const char *routineName = "GGSRunManagerExtensions::IsKilledAndToBeSimulatedAgain";
  if (_isCurrEvKilled) {
    GGSCOUT(DEEPDEB) << "Event " << ev->GetEventID() << " has been killed. " << GGSENDL;
    if (_ggsGeneratorAction) {
      GGSCCOUT(DEEPDEB) << "Discarded at generation: " << _ggsGeneratorAction->GetNDiscarded()
                        << " (total: " << _nDiscardedEvsInKilledEvs << ")" << GGSENDL;
    }
    if (_simAgainKilledEv) {
      GGSCCOUT(DEEPDEB) << "Will be simulated again." << GGSENDL;
      return true;
    }
  } else {
    GGSCOUT(DEEPDEB) << "Finished simulating event " << ev->GetEventID() << GGSENDL;
    if (_ggsGeneratorAction) {
      GGSCCOUT(DEEPDEB) << "Discarded at generation: " << _ggsGeneratorAction->GetNDiscarded()
                        << " (total: " << GetNDiscardedEvents() << ")" << GGSENDL;
    }
    GGSCCOUT(DEEPDEB) << "Killed: " << _nKilledEvs << GGSENDL;
    // Reset discarded and killed event counters
    _nDiscardedEvsInKilledEvs = 0;
    _nKilledEvs = 0;
    if (_simAgainKilledEv) {
      static bool printDone = false;
      if (!printDone) {
        GGSCOUT(WARNING) << "Request to re-simulate an event which has not been flagged as killed. Ignoring."
                         << GGSENDL;
        GGSCCOUT(WARNING) << "This message will be printed only once." << GGSENDL;
        printDone = true;
      }
    }
  }
  return false;
}

void GGSRunManagerExtensions::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 35 of file GGSRunManagerExtensions.cpp.

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

const std::string& GGSRunManagerExtensions::RngStateRestoredFrom ( )

inline

The random engine state file for this event.

Returns the name of the file from which the random engine state for the current event has been restored.

Returns

The name of the file used to restore the random engine state, or an empty string if the state was not restored from file.

Definition at line 124 of file GGSRunManagerExtensions.h.

{ return _restoredFrom; }

void GGSRunManagerExtensions::SetGGSGeneratorAction

(

G4VUserPrimaryGeneratorAction *

userAction

)

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 129 of file GGSRunManagerExtensions.cpp.

                                                                                             {
  // dynamic_cast to references to throw exceptions in case of errors
  _ggsGeneratorAction = &(dynamic_cast<GGSGeneratorAction &>(*userAction));
  auto &rmExt = dynamic_cast<G4RunManager &>(*this);
  rmExt.SetUserAction(userAction);
}

void GGSRunManagerExtensions::SimulateAgainKilledEvent ( )

inline

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 68 of file GGSRunManagerExtensions.h.

{ _simAgainKilledEv = true; };

---

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

• GGSRunManagerExtensions.h
• GGSRunManagerExtensions.cpp