gRunAction.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <vector>
 
// geant4
#include "G4UserRunAction.hh"
 
// gemc
#include <gemc/gbase/gbase.h>
#include <gemc/ganalysis/gAnalysisAccumulator.h>
#include <gemc/gdynamicDigitization/gdynamicdigitization.h>
#include <gemc/gstreamer/gstreamer.h>
#include <gemc/gstreamer/factories/SRO/gSROFactory.h>
#include <gemc/gdata/run/gRunDataCollection.h>
#include <gemc/actions/gactionConventions.h>
 

 
constexpr const char* GRUNACTION_LOGGER = "grunaction";

namespace grunaction {
    inline GOptions defineOptions() { return GOptions(GRUNACTION_LOGGER); }
} // namespace grunaction
 

class GRunAction : public GBase<GRunAction>, public G4UserRunAction
{
public:
    explicit GRunAction(std::shared_ptr<GOptions>                           gopts,
                        std::shared_ptr<gdynamicdigitization::dRoutinesMap> digi_map,
                        std::shared_ptr<GAnalysisAccumulator> analysis_accumulator = nullptr,
                        std::shared_ptr<GSROFactory> sro_factory = nullptr);
 
    ~GRunAction() override = default;
 
    [[nodiscard]] const std::shared_ptr<GSROFactory>& get_sro_factory() const { return sro_factory; }
 
    // The run action manages thread-local and process-wide state and is therefore
    // intentionally non-copyable and non-movable.
    GRunAction(const GRunAction&)            = delete;
    GRunAction& operator=(const GRunAction&) = delete;
    GRunAction(GRunAction&&)                 = delete;
    GRunAction& operator=(GRunAction&&)      = delete;

    [[nodiscard]] auto get_digitization_routines_map() const
        -> std::shared_ptr<gdynamicdigitization::dRoutinesMap> {
        return digitization_routines_map;
    }

    [[nodiscard]] auto get_streamer_threads_map() const
        -> std::shared_ptr<const gstreamer::gstreamersMap> {
        if (!gstreamer_threads_map) {
            log->error(
                gaction::ERR_STREAMERMAP_NOT_EXISTING, "%1 no gstreamer thread map available", FUNCTION_NAME);
        }
        return gstreamer_threads_map;
    }
 
    [[nodiscard]] bool has_streamer_threads_map() const {
        return gstreamer_threads_map != nullptr;
    }

    [[nodiscard]] bool analysis_enabled() const { return analysis_shard != nullptr; }

    void record_analysis_digitized(const std::string& detector, const GDigitizedData& data) {
        if (analysis_shard != nullptr) {
            analysis_shard->recordDigitized(requiredAnalysisRunNumber(), detector, data);
        }
    }

    void record_analysis_true(const std::string& detector, const GTrueInfoData& data) {
        if (analysis_shard != nullptr) {
            analysis_shard->recordTrueInformation(requiredAnalysisRunNumber(), detector, data);
        }
    }

    void collect_event_data_collections(const std::string&              hcSDName,
                                        std::unique_ptr<GDigitizedData> digi_data) {
        if (run_data == nullptr) {
            log->error(
                gaction::ERR_GRUNACTION_NOT_EXISTING,
                "%1 run_data is null - cannot collect run-level payload for collection %2", FUNCTION_NAME,
                hcSDName);
        }
 
        run_data->collect_event_data_collections(
                                                 hcSDName,
                                                 std::move(digi_data));
    }

    void increment_run_events_processed() {
        if (run_data == nullptr) {
            log->error(
                gaction::ERR_GRUNACTION_NOT_EXISTING,
                "%1 run_data is null - cannot increment processed events.", FUNCTION_NAME);
        }
 
        auto& header = run_data->getHeader();
        if (header == nullptr) {
            log->error(
                gaction::ERR_GRUNACTION_NOT_EXISTING,
                "%1 run_data header is null - cannot increment processed events.", FUNCTION_NAME);
        }
 
        header->increment_events_processed();
    }

    void increment_run_events_with_payload() {
        if (run_data == nullptr) {
            log->error(
                gaction::ERR_GRUNACTION_NOT_EXISTING, "%1 run_data is null - cannot increment payload events.",
                FUNCTION_NAME);
        }
 
        auto& header = run_data->getHeader();
        if (header == nullptr) {
            log->error(
                gaction::ERR_GRUNACTION_NOT_EXISTING,
                "%1 run_data header is null - cannot increment payload events.", FUNCTION_NAME);
        }
 
        header->increment_events_with_payload();
    }
 
private:
    using CompletedRunData = std::vector<std::unique_ptr<GRunDataCollection>>;

    void stash_worker_run_data();

    [[nodiscard]] CompletedRunData take_completed_worker_run_data();

    G4Run* GenerateRun() override;

    void BeginOfRunAction(const G4Run* run) override;

    void EndOfRunAction(const G4Run* run) override;

    void publish_run_data(const std::shared_ptr<GRunDataCollection>& run_data) const;

    std::shared_ptr<GOptions> goptions;

    std::shared_ptr<gdynamicdigitization::dRoutinesMap> digitization_routines_map;

    std::shared_ptr<GAnalysisAccumulator> analysis_accumulator;

    std::shared_ptr<GSROFactory> sro_factory;

    std::unique_ptr<GAnalysisShard> analysis_shard;

    std::optional<int> analysis_run_number;
 
    [[nodiscard]] int requiredAnalysisRunNumber() const {
        if (!analysis_run_number) {
            throw std::logic_error("Analyzer data recorded before the simulation run number was published");
        }
        return *analysis_run_number;
    }

    std::shared_ptr<const gstreamer::gstreamersMap> gstreamer_threads_map;

    std::shared_ptr<const gstreamer::gstreamersMap> gstreamer_run_map;

    std::unique_ptr<GRunDataCollection> run_data;

    bool need_a_thread_streamer = false;

    bool need_a_run_streamer = false;

    static std::mutex completed_run_data_mutex;

    static CompletedRunData completed_worker_run_data;

    void normalize_run_data(const std::shared_ptr<GRunDataCollection>& run_data) const;
 
    // coming from digitization routine
    std::unordered_map<std::string, std::vector<std::string>> to_normalize;
};
 
 
// vector of frame data in the run (local thread, merged in GRun::Merge in the global thread)
//  std::vector<GFrameDataCollection*> frameRunData;
 
//
// int    eventIndex       = 0;                           // added to the absolute event number, increases with each run
// int    lastFrameCreated = 0;                           // keeping track of the last frame created
//
// // determine the frame ID based on event number, eventDuration, frameDuration
// // TODO: this should be in gdata?
// int  eventFrameIndex(int eventNumber, double timeAtElectronics);
// bool findFrameID(int fid);
//
// // decide whether to write or not to stream the frame based on event number, eventDuration, frameDuration and number of threads
// // streaming the frame also deletes it from frameRunData
// // TODO: this should be in gdata?
// bool shouldWriteFrameID(int eventNumber, long int frameID);
//
// // TODO: this should be in gdata?
// std::vector<int> formPayload(GDigitizedData* digitizedData);
 
 
// in the constructur we had:
 
// frameDuration = 64000;
// eventDuration = gparticle::getEventTimeWidth(goptions);
 
// stream = gopt->getSwitch("stream");