eventDispenser.h

Go to the documentation of this file.

#pragma once
 
#include <gemc/gbase/gbase.h>
#include <gemc/ganalysis/gAnalysisAccumulator.h>
#include <gemc/gdynamicDigitization/gdynamicdigitization.h>
 
#include <chrono>
#include <map>
#include <memory>
#include <optional>
#include <stdexcept>
#include <vector>


class EventDispenser : public GBase<EventDispenser>
{
public:
    EventDispenser(const std::shared_ptr<GOptions>&                                 gopt,
                   const std::shared_ptr<const gdynamicdigitization::dRoutinesMap>& gdynamicDigitizationMap,
                   std::shared_ptr<GAnalysisAccumulator> analysisAccumulator = nullptr);
 
private:

    int neventsToProcess;

    int userRunno;

    bool offscreen_screenshots = false;

    std::optional<int> currentRunno;



    std::map<int, double> runWeights;

    std::map<int, int> runEvents;

    std::vector<int> listOfRuns;

    int currentRunIndex{};

    std::optional<std::chrono::steady_clock::time_point> beamOnTime;


    void distributeEvents(int nevents_to_process);

    void setNextRun() { currentRunIndex++; }

    std::shared_ptr<const gdynamicdigitization::dRoutinesMap> gDigitizationMap;

    std::shared_ptr<GAnalysisAccumulator> analysisAccumulator;
 
public:
    std::map<int, int> getRunEvents() { return runEvents; }

    [[nodiscard]] int getCurrentRun() const { return listOfRuns[currentRunIndex]; }

    [[nodiscard]] int getTotalNumberOfEvents() const;

    int processEvents();

    [[nodiscard]] bool beamOnIssued() const { return beamOnTime.has_value(); }

    [[nodiscard]] std::chrono::steady_clock::time_point beamOnStartTime() const {
        if (!beamOnTime) {
            throw std::logic_error("beamOnStartTime() called before the first /run/beamOn");
        }
        return *beamOnTime;
    }

    void setNumberOfEvents(int nevts);

    void resetRunContext();
};