GGSRunManagerExtensions.cpp

/*
 * GGSRunManagerExtensions.cpp
 *
 *  Created on: 5 Nov 2020
 *      Author: Nicola Mori
 */

#include "montecarlo/mccore/GGSRunManagerExtensions.h"
#include "utils/GGSSmartLog.h"

#include "G4LogicalVolumeStore.hh"
#include "G4Run.hh"

GGSRunManagerExtensions::GGSRunManagerExtensions()
    : _nDiscardedEvsInKilledEvs(0), _nKilledEvs(0), _isCurrEvKilled(false), _simAgainKilledEv(false),
      _ggsGeneratorAction(nullptr), _eventRandomFileBase(""), _eventRandomFilePath(""), _restoredFrom(""),
      _readEventRngStateFromFile(false), _saveEventRngStateToFile(false), _messenger(this, "/GGS/"),
      _randomMessenger(this, "/GGS/random/") {

  _messenger.DeclareMethod("printLogVols", &GGSRunManagerExtensions::PrintLogVols, "Print a list of logical volumes.");
  _messenger.DeclareProperty("rndmPrintModulo", _printModulo,
                             "Set the number of events between two dumps on screen of the random engine status "
                             "(set to 0 to disable the dump).");

  _randomMessenger.DeclareProperty("eventRngStateFileBase", _eventRandomFileBase,
                                   "Base name for random generator state files of each event");
  _randomMessenger.DeclareProperty("eventRngStateFilePath", _eventRandomFilePath,
                                   "Path for random generator state files of each event");
  _randomMessenger.DeclareProperty("readEventRngStateFromFile", _readEventRngStateFromFile,
                                   "Read the random number generator state for each event from file");
  _randomMessenger.DeclareProperty("saveEventRngStateToFile", _saveEventRngStateToFile,
                                   "Save the random number generator state for each event to file");
}

void GGSRunManagerExtensions::KillEvent() {
  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();
  }
}

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

void GGSRunManagerExtensions::BeginOfEventSimulation() {
  _isCurrEvKilled = false;
  _simAgainKilledEv = false;
}

void GGSRunManagerExtensions::DumpStatus(G4int eventID) {
  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;
    }
  }
}

bool GGSRunManagerExtensions::IsKilledAndToBeSimulatedAgain(const G4Event *ev) {
  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::SetGGSGeneratorAction(G4VUserPrimaryGeneratorAction *userAction) {
  // 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);
}

int GGSRunManagerExtensions::GetNDiscardedEvents() {
  if (_ggsGeneratorAction) {
    return _nDiscardedEvsInKilledEvs + _ggsGeneratorAction->GetNDiscarded();
  }
  return 0;
}

void GGSRunManagerExtensions::PrintLogVols() {
  static const std::string routineName("GGSRunManagerExtensions::PrintLogVols");
  G4LogicalVolumeStore *logVolStore = G4LogicalVolumeStore::GetInstance();

  GGSCOUT(INFO) << "Logical volumes in current geometry:" << GGSENDL;
  for (auto &logVol : *logVolStore) {
    GGSCCOUT(INFO) << " * " << logVol->GetName() << GGSENDL;
  }
}

void GGSRunManagerExtensions::HandleEventRngStateFile(int runID, int eventID) {
  _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);
    }
  }
}