gEventAction.h

Go to the documentation of this file.

#pragma once
 
// geant4
#include "G4UserEventAction.hh"
 
// gemc
#include <gemc/gbase/gbase.h>
#include <gemc/actions/run/gRunAction.h>
 
// c++
#include <chrono>
 
class GTrackProvenance;

 
constexpr const char* EVENTACTION_LOGGER = "geventaction";

constexpr const char* LOG_EVERY_OPTION = "log_every";
constexpr const char* SAVE_ORIGINAL_TRACK_SWITCH = "save_original_track";
constexpr const char* SAVE_ALL_ANCESTORS_SWITCH = "save_all_ancestors";
constexpr const char* NO_DIGITIZED_OPTION = "no_digitized";
constexpr const char* NO_TRUE_INFO_OPTION = "no_true_info";

namespace geventaction {
    inline GOptions defineOptions() {
        GOptions goptions(EVENTACTION_LOGGER);
 
        std::string help = "Print a progress log line every N events, with the average event rate.\n \n";
        help += guts::GTAB;
        help += "The value is a string of the form N or N-NTH, where N is the log module:\n";
        help += guts::GTABTAB;
        help += "N     : every worker thread prints 'Starting event n. <k> in thread <tid>.\n";
        help += guts::GTABTABTAB;
        help += "Average rate: <r> events / second' every time it has processed a multiple\n";
        help += guts::GTABTABTAB;
        help += "of N events. <k> is that thread's own 1-based event count (not the global\n";
        help += guts::GTABTABTAB;
        help += "Geant4 event id), and <r> is that thread's average rate.\n";
        help += guts::GTABTAB;
        help += "N-NTH : as above, but only the worker thread with id NTH prints. NTH must be\n";
        help += guts::GTABTABTAB;
        help += "in the range [0, nthreads-1].\n \n";
        help += guts::GTAB;
        help += "Examples: -log_every=100 (all threads, every 100 events)\n";
        help += guts::GTABTAB;
        help += "-log_every=100-2 (only thread 2, every 100 events)\n";
        goptions.defineOption(
            GVariable(LOG_EVERY_OPTION, std::nullopt,
                      "log module: print event progress and average rate every N events per thread"),
            help);
 
        goptions.defineSwitch(SAVE_ORIGINAL_TRACK_SWITCH,
                              "save the original Geant4 track ID in each true-information hit");
        goptions.defineSwitch(SAVE_ALL_ANCESTORS_SWITCH,
                              "save initial information for hit-producing tracks and all their ancestors");
        goptions.defineOption(
            GVariable(NO_DIGITIZED_OPTION, std::nullopt, "detectors for which digitization is disabled"),
            "Disable digitization for a comma- or whitespace-separated list of detector names.\n"
            "Use \"all\" to disable digitization for every detector. Default: none.\n \n"
            "Example: -no_digitized=\"ftof, ecal\"");
        goptions.defineOption(
            GVariable(NO_TRUE_INFO_OPTION, std::nullopt,
                      "detectors for which true-information output is disabled"),
            "Disable true-information output for a comma- or whitespace-separated list of detector names.\n"
            "Use \"all\" to disable true-information output for every detector. Default: none.\n \n"
            "Example: -no_true_info=\"ftof, ecal\"");
 
        return goptions;
    }
} // namespace geventaction
 

class GEventAction : public GBase<GEventAction>, public G4UserEventAction
{
public:
    explicit GEventAction(const std::shared_ptr<GOptions>& gopt, GRunAction* run_a,
                          std::shared_ptr<GTrackProvenance> provenance = nullptr);
 
    ~GEventAction() override = default;
 
    GEventAction(const GEventAction&)            = delete;
    GEventAction& operator=(const GEventAction&) = delete;
    GEventAction(GEventAction&&)                 = delete;
    GEventAction& operator=(GEventAction&&)      = delete;

    void BeginOfEventAction(const G4Event* event) override;

    void EndOfEventAction(const G4Event* event) override;
 
private:
    void publish_event_data(const std::shared_ptr<GEventDataCollection>& event_data) const;

    void log_event_start(int thread_id);

    long long log_events_seen = 0;

    std::chrono::steady_clock::time_point log_start_time;

    std::shared_ptr<GOptions> goptions;

    int log_every_n = 0;

    int log_every_thread = -1;

    GRunAction* run_action = nullptr;

    std::shared_ptr<GTrackProvenance> track_provenance;
 
    bool save_original_track = false;
    bool save_all_ancestors  = false;
};
 
// looping over output factories
// for (auto [factoryName, streamerFactory] : *gstreamerFactoryMap) {
//  if (streamerFactory->getStreamType() == "event") {
//      logSummary("Writing event data using streamer factory >" + factoryName + "<");
//      map<string, bool> streamReport = streamerFactory->publishEventRunData(goptions, theRun->getRunData());
//
//      for (auto [reportName, result] : streamReport) {
//          string resultString = result ? " success" : " failure";
//          logSummary("Factory <" + factoryName + "> " + reportName + resultString);
//      }
//  }
// }