GGSWorkerRunManager.cpp

/*
 * GGSWorkerRunManager.cpp
 *
 *  Created on: 4 Nov 2020
 *      Author: Nicola Mori
 */

#include "montecarlo/mccore/GGSWorkerRunManager.h"

#include "G4MTRunManager.hh"
#include "G4Run.hh"
#include "G4TiMemory.hh"
#include "G4UImanager.hh"

void GGSWorkerRunManager::DoEventLoop(G4int n_event, const char *macroFile, G4int n_select) {
  // Implementation copy-pasted from G4 10.06.p02 with no modification, to just allow for binding the call to
  // ProcessOneEvent to the override defined in this class.
  TIMEMORY_AUTO_TIMER("");
  if (!userPrimaryGeneratorAction) {
    G4Exception("G4RunManager::GenerateEvent()", "Run0032", FatalException,
                "G4VUserPrimaryGeneratorAction is not defined!");
  }

  // This is the same as in the sequential case, just the for-loop indexes are
  // different
  InitializeEventLoop(n_event, macroFile, n_select);

  // Reset random number seeds queue
  while (seedsQueue.size() > 0) {
    seedsQueue.pop();
  }
  // for each run, worker should receive at least one set of random number seeds.
  runIsSeeded = false;

  // Event loop
  eventLoopOnGoing = true;
  G4int i_event = -1;
  nevModulo = -1;
  currEvID = -1;

  while (eventLoopOnGoing) {
    ProcessOneEvent(i_event);
    if (eventLoopOnGoing) {
      TerminateOneEvent();
      if (runAborted) {
        eventLoopOnGoing = false;
      }
    }
  }

  TerminateEventLoop();
}

void GGSWorkerRunManager::ProcessOneEvent(G4int i_event) {

  TIMEMORY_AUTO_TIMER("");
  currentEvent = _SetupRandomNumbers(i_event);
  // _SetupRandomNumbers will set eventLoopOnGoing to false and return nullptr if the event loop is already finished, so
  // check before going on.
  if (eventLoopOnGoing) {
    BeginOfEventProcessing();
    userPrimaryGeneratorAction->GeneratePrimaries(currentEvent);
    DumpStatus(currentEvent->GetEventID());
    bool resim = true;
    while (resim) {
      BeginOfEventSimulation();
      eventManager->ProcessOneEvent(currentEvent);
      resim = IsKilledAndToBeSimulatedAgain(currentEvent);
      if (resim) {
        // Create a new G4Event for this event
        G4Event *newEvent = new G4Event(currentEvent->GetEventID());
        delete currentEvent;
        currentEvent = newEvent;
        userPrimaryGeneratorAction->GeneratePrimaries(currentEvent);
      }
    }
    AnalyzeEvent(currentEvent);
    UpdateScoring();
    if (currentEvent->GetEventID() < n_select_msg)
      G4UImanager::GetUIpointer()->ApplyCommand(msgText);
  }
}

G4Event *GGSWorkerRunManager::_SetupRandomNumbers(G4int i_event) {
  // Implementation copy-pasted from G4WorkerRunManager::GenerateEvent in G4 10.06.p02, with these modifications:
  // 1. don't generate of the event at the end.
  // 2. offload the handling of seeds files to GGSRunManagerExtensions::HandleEventRngStateFile

  TIMEMORY_AUTO_TIMER("");
  G4Event *anEvent = new G4Event(i_event);
  long s1 = 0;
  long s2 = 0;
  long s3 = 0;
  G4bool eventHasToBeSeeded = true;
  if (G4MTRunManager::SeedOncePerCommunication() == 1 && runIsSeeded) {
    eventHasToBeSeeded = false;
  }

  if (i_event < 0) {
    G4int nevM = G4MTRunManager::GetMasterRunManager()->GetEventModulo();
    if (nevM == 1) {
      eventLoopOnGoing = G4MTRunManager::GetMasterRunManager()->SetUpAnEvent(anEvent, s1, s2, s3, eventHasToBeSeeded);
      runIsSeeded = true;
    } else {
      if (nevModulo <= 0) {
        G4int nevToDo = G4MTRunManager::GetMasterRunManager()->SetUpNEvents(anEvent, &seedsQueue, eventHasToBeSeeded);
        if (nevToDo == 0) {
          eventLoopOnGoing = false;
        } else {
          currEvID = anEvent->GetEventID();
          nevModulo = nevToDo - 1;
        }
      } else {
        if (G4MTRunManager::SeedOncePerCommunication() > 0)
          eventHasToBeSeeded = false;
        anEvent->SetEventID(++currEvID);
        nevModulo--;
      }
      if (eventLoopOnGoing && eventHasToBeSeeded) {
        s1 = seedsQueue.front();
        seedsQueue.pop();
        s2 = seedsQueue.front();
        seedsQueue.pop();
      }
    }

    if (!eventLoopOnGoing) {
      delete anEvent;
      return 0;
    }
  } else if (eventHasToBeSeeded) {
    // Need to reseed random number generator
    G4RNGHelper *helper = G4RNGHelper::GetInstance();
    s1 = helper->GetSeed(i_event * 2);
    s2 = helper->GetSeed(i_event * 2 + 1);
  }

  if (eventHasToBeSeeded) {
    long seeds[3] = {s1, s2, 0};
    G4Random::setTheSeeds(seeds, luxury);
    runIsSeeded = true;
  }

  HandleEventRngStateFile(currentRun->GetRunID(), anEvent->GetEventID());

  if (storeRandomNumberStatusToG4Event == 1 || storeRandomNumberStatusToG4Event == 3) {
    std::ostringstream oss;
    G4Random::saveFullState(oss);
    randomNumberStatusForThisEvent = oss.str();
    anEvent->SetRandomNumberStatus(randomNumberStatusForThisEvent);
  }

  if (printModulo > 0 && anEvent->GetEventID() % printModulo == 0) {
    G4cout << "--> Event " << anEvent->GetEventID() << " starts";
    if (eventHasToBeSeeded) {
      G4cout << " with initial seeds (" << s1 << "," << s2 << ")";
    }
    G4cout << "." << G4endl;
  }

  return anEvent;
}