eventDispenser.cc

Go to the documentation of this file.

// Implements EventDispenser: run-weight parsing, event distribution, and per-run dispatch through Geant4.
//
// Doxygen documentation for the public API is maintained in eventDispenser.h.
// This implementation file keeps only short, non-Doxygen summaries and inline clarifying comments.
 
#include "eventDispenserConventions.h"
#include "eventDispenser_options.h"
#include "eventDispenser.h"
#include "gdynamicdigitizationConventions.h"
 
// c++
#include <fstream>
#include <random>
#include <utility>
 
// geant4
#include "G4GeometryManager.hh"
#include "G4UImanager.hh"
#include "G4RunManager.hh"
 
using namespace std;
 
namespace {
void closeOpenGeometryBeforeBeamOn(const std::shared_ptr<GLogger>& log) {
    auto* geometryManager = G4GeometryManager::GetInstanceIfExist();
    if (!geometryManager || geometryManager->IsGeometryClosed()) { return; }
 
    log->info(1, "Geometry is open before BeamOn; closing it before event processing.");
    geometryManager->CloseGeometry();
}
}
 
// Constructor summary:
// - Reads configuration (number of events, run number, optional run-weight file).
// - Builds runWeights/runEvents/listOfRuns when weights are provided.
// - Otherwise, falls back to single-run mode.
EventDispenser::EventDispenser(
    const std::shared_ptr<GOptions>& gopt,
    const std::shared_ptr<const gdynamicdigitization::dRoutinesMap>& gdynamicDigitizationMap,
    std::shared_ptr<GAnalysisAccumulator> analyzer)
    : GBase(gopt, EVENTDISPENSER_LOGGER), gDigitizationMap(gdynamicDigitizationMap),
      analysisAccumulator(std::move(analyzer)) {
    // Retrieve configuration parameters from GOptions.
    const auto filename = gopt->getOptionalScalarString("run_weights");
    userRunno        = gopt->getRequiredScalarInt("run");
    neventsToProcess = gopt->getRequiredScalarInt("n");
 
    // Detect offscreen mode once at construction so processEvents() needs no vis headers.
    // g4view is only defined when g4display options are included (e.g. in the full gemc app).
    if (gopt->doesOptionExist("g4view")) {
        auto driverNode = gopt->getOptionMapInNode("g4view", "driver");
        if (!driverNode.IsNull() && driverNode.IsDefined()) {
            offscreen_screenshots = (driverNode.as<std::string>() == "TOOLSSG_OFFSCREEN");
        }
    }
 
    // If there are no events to process, keep the object in an initialized-but-idle state.
    if (neventsToProcess == 0) return;
 
    // If no file is provided, use the user-specified run number (single-run mode).
    if (!filename && neventsToProcess > 0) {
        runEvents[userRunno] = neventsToProcess;
        return;
    }
    else {
        // Multi-run mode: a filename was specified; attempt to open the run weights input file.
        ifstream in(filename->c_str());
        if (!in) {
            // Keep behavior unchanged: log error and continue with an empty distribution.
            log->error(
                eventDispenser::ERR_EVENTDISTRIBUTIONFILENOTFOUND,
                "Error: can't open run weights input file >%1<. Check your spelling. Exiting.", *filename);
        }
        else {
            log->info(1, "Loading run weights from %1", *filename);
 
            // Read "run weight" pairs, one per line.
            // The order of insertion into listOfRuns reflects the file order and may be used by clients.
            int    run;
            double weight;
            while (in >> run >> weight) {
                listOfRuns.push_back(run);
                runWeights[run] = weight;
                runEvents[run]  = 0; // initialize per-run counters before distribution
            }
 
            // Distribute the total number of events among runs according to their weights.
            distributeEvents(neventsToProcess);
        }
        in.close();
 
        // Log summary information: overall distribution table.
        log->info(
            0, "EventDispenser initialized with %1 events distributed among %2 runs:", neventsToProcess,
            runWeights.size());
        log->info(0, " run\t weight\t  n. events");
        for (const auto& weight : runWeights) {
            log->info(0, " %1\t %2\t  %3", weight.first, weight.second, runEvents[weight.first]);
        }
    }
}
 
 
// setNumberOfEvents summary:
// - Clears any existing distribution and assigns all events to the user-selected run number.
void EventDispenser::setNumberOfEvents(int nevents_to_process) {
    runEvents.clear();
    runEvents[userRunno] = nevents_to_process;
}
 
void EventDispenser::resetRunContext() {
    currentRunno.reset();
}
 
 
// distributeEvents summary:
// - Performs stochastic sampling to convert runWeights into integer runEvents counts.
void EventDispenser::distributeEvents(int nevents_to_process) {
    // Set up a random number generator drawing from U[0, 1].
    random_device               randomDevice;
    mt19937                     generator(randomDevice());
    uniform_real_distribution<> randomDistribution(0, 1);
 
    // Weights in the run-weights file are relative, not required to sum to 1. Compute the total
    // once and scale each draw by it, so non-normalized weights distribute events correctly.
    double totalWeight = 0;
    for (const auto& weight : runWeights) { totalWeight += weight.second; }
    if (totalWeight <= 0) {
        log->error(
            eventDispenser::ERR_EVENTDISTRIBUTIONFILENOTFOUND,
            "Run weights sum to %1 (must be > 0). Check your run weights file.", totalWeight);
        return;
    }
 
    // For each event, select a run by comparing a random draw to the cumulative weight intervals.
    for (int i = 0; i < nevents_to_process; i++) {
        double randomNumber = randomDistribution(generator) * totalWeight;
 
        double cumulativeWeight = 0;
        for (const auto& weight : runWeights) {
            cumulativeWeight += weight.second;
            if (randomNumber <= cumulativeWeight) {
                runEvents[weight.first]++;
                break;
            }
        }
    }
}
 
 
// getTotalNumberOfEvents summary:
// - Sums all per-run event counts from runEvents.
int EventDispenser::getTotalNumberOfEvents() const {
    int totalEvents = 0;
    for (auto rEvents : runEvents) { totalEvents += rEvents.second; }
    return totalEvents;
}
 
 
void EventDispenser::prepareRun(int runNumber) {
    // Load constants and translation tables if the run number has changed.
    if (!currentRunno || runNumber != *currentRunno) {
        // Iterate the (plugin name -> digitization routine) map.
        // digiRoutine is a std::shared_ptr<GDynamicDigitization>.
        for (const auto& [plugin, digiRoutine] : *gDigitizationMap) {
            // The variation is resolved per routine at geometry load (gsystem variation,
            // or the digitization_variation option override when set).
            const std::string& variation = digiRoutine->getDigitizationVariation();
 
            log->debug(
                NORMAL, "%1Calling %2 loadConstants for run %3 with variation %4", FUNCTION_NAME, plugin,
                runNumber, variation);
            if (digiRoutine->loadConstants(runNumber, variation) == false) {
                log->error(
                    ERR_LOADCONSTANTFAIL, "Failed to load constants for %1 for run %2 with variation %3",
                    plugin, runNumber, variation);
            }
 
            log->debug(NORMAL, "%1Calling %2 loadTT for run %3", FUNCTION_NAME, plugin, runNumber);
            if (digiRoutine->loadTT(runNumber, variation) == false) {
                log->error(
                    ERR_LOADTTFAIL, "Failed to load translation table for %1 for run %2 with variation %3",
                    plugin, runNumber, variation);
            }
        }
        currentRunno = runNumber;
    }
 
    if (analysisAccumulator != nullptr) { analysisAccumulator->setCurrentRunNumber(runNumber); }
    // Tag the next G4Run with this run number. Guarded because standalone/unit-test
    // contexts (e.g. the event_dispenser example) may run without a G4RunManager.
    if (G4RunManager* g4rm = G4RunManager::GetRunManager()) { g4rm->SetRunIDCounter(runNumber); }
 
    closeOpenGeometryBeforeBeamOn(log);
}
 
 
// processEvents summary:
// - Iterates the run allocation.
// - For each run, loads run-dependent constants/TT via digitization routines (if run changed).
// - Dispatches the events to Geant4 via \c /run/beamOn.
int EventDispenser::processEvents() {
    // Get the Geant4 UI manager pointer used to apply macro commands.
    G4UImanager* g4uim = G4UImanager::GetUIpointer();
 
    // Iterate over each run in the run events map.
    for (auto& run : runEvents) {
        int runNumber = run.first;
        int nevents   = run.second;
 
        prepareRun(runNumber);
        log->info(1, "Starting run %1 with %2 events.", runNumber, nevents);
 
        // Dispatch all events for this run in a single call.
        // The command string is a standard Geant4 UI command: \c /run/beamOn <N>.
        log->info(1, "Processing %1 events in one go", nevents);
        // Record the moment the first BeamOn is issued so a timing summary can be produced later.
        if (!beamOnTime.has_value()) { beamOnTime = std::chrono::steady_clock::now(); }
        g4uim->ApplyCommand("/run/beamOn " + to_string(nevents));
        // Take the screenshot after BeamOn returns. At this point G4VisManager::EndOfRun()
        // has already joined the vis subthread (ARM64 offset 0xa35f8: bl thread::join), so
        // DrawEvent calls are finished — no concurrent scene-graph writes. The transient store
        // is still intact: the vis subthread's exit cleanup only runs after running=0 is set
        // inside G4VisManager::EndOfRun(), which completes inside BeamOn before it returns.
        if (offscreen_screenshots) {
            g4uim->ApplyCommand("/vis/tsg/offscreen/set/size 3000 2000");
            g4uim->ApplyCommand("/vis/tsg/offscreen/set/file gemc_run_" + to_string(runNumber) + ".png");
            g4uim->ApplyCommand("/vis/viewer/rebuild");
        }
 
        log->info(1, "Run %1 done with %2 events", runNumber, nevents);
    }
 
    return 1;
}