event_example.cc

Go to the documentation of this file.

 
// gdata
#include "event/gEventDataCollection.h" // Explicit include for the example entry point.
 
// gemc
#include "glogger.h"
#include "gthreads.h"
 
// C++
#include <atomic>
#include <cstdlib>
#include <map>
#include <mutex>
#include <sstream>
#include <string>
#include <vector>

template <typename MapType>
static std::string map_to_string(const MapType& m) {
    std::ostringstream os;
    os << "{";
    bool first = true;
    for (const auto& [k, v] : m) {
        if (!first) os << ", ";
        first = false;
        os << k << "=" << v;
    }
    os << "}";
    return os.str();
}

static void dump_event(const std::shared_ptr<GEventDataCollection>& edc, const std::shared_ptr<GLogger>& log) {
    log->info(0, "------------------------------------------------------------");
    log->info(0, "Dumping event: local event number = ", edc->getEventNumber());
    log->info(0, "------------------------------------------------------------");
 
    const auto& dcm = edc->getDataCollectionMap();
    if (dcm.empty()) {
        log->info(0, "Event contains no detector data.");
        return;
    }
 
    for (const auto& [sdName, det] : dcm) {
        if (!det) {
            log->info(0, "Detector <", sdName, "> has a null GDataCollection pointer (unexpected).");
            continue;
        }
 
        const auto& truthHits = det->getTrueInfoData();
        const auto& digiHits  = det->getDigitizedData();
 
        log->info(0, "Detector <", sdName, ">: truthHits=", truthHits.size(), " digitizedHits=", digiHits.size());
 
        // Truth hits are printed first so the example shows the simulation-side view before the readout-side view.
        for (size_t i = 0; i < truthHits.size(); ++i) {
            const auto& th = truthHits[i];
            if (!th) continue;
 
            const auto doubles = th->getDoubleVariablesMap();
            const auto strings = th->getStringVariablesMap();
 
            auto idString = getIdentityString(th->getIdentity());
 
            log->info(0, "  [truth hit ", i, "] id={",idString, "}");
            log->info(0, "    doubles: ", map_to_string(doubles));
 
            // Strings are often empty in this toy factory, but the code shows how to inspect them.
            if (!strings.empty()) {
                log->info(0, "    strings: ", map_to_string(strings));
            }
            else {
                log->info(0, "    strings: {} (none)");
            }
        }
 
        // Digitized hits are printed with both SRO and non-SRO filtered views.
        for (size_t i = 0; i < digiHits.size(); ++i) {
            const auto& dh = digiHits[i];
            if (!dh) continue;
 
            const auto ints_non_sro  = dh->getIntObservablesMap(0);
            const auto ints_sro      = dh->getIntObservablesMap(1);
            const auto dbls_non_sro  = dh->getDblObservablesMap(0);
            const auto dbls_sro_only = dh->getDblObservablesMap(1);
 
            auto idString = getIdentityString(dh->getIdentity());
 
            log->info(0, "  [digi  hit ", i, "] id={",idString, "}");
            log->info(0, "    int  non-SRO: ", map_to_string(ints_non_sro));
            log->info(0, "    int  SRO:     ", map_to_string(ints_sro));
            log->info(0, "    dbl  non-SRO: ", map_to_string(dbls_non_sro));
            log->info(0, "    dbl  SRO:     ", map_to_string(dbls_sro_only));
 
            // Demonstrate the convenience accessor for one common SRO quantity.
            const auto electronicsTime = dh->getTimeAtElectronics();
            log->info(0, "    timeAtElectronics() = ",
                      electronicsTime ? std::to_string(*electronicsTime) : "not available");
        }
    }
}

static void validate_event_structure(const std::shared_ptr<GEventDataCollection>& edc,
                                     const std::shared_ptr<GLogger>&              log) {
    const auto& dcm = edc->getDataCollectionMap();
    if (dcm.empty()) {
        log->info(0, "VALIDATION: event ", edc->getEventNumber(), " has no detectors (unexpected in this example).");
        return;
    }
 
    for (const auto& [sdName, det] : dcm) {
        if (!det) {
            log->info(0, "VALIDATION: detector <", sdName, "> has null GDataCollection pointer.");
            continue;
        }
 
        const auto& truthHits = det->getTrueInfoData();
        const auto& digiHits  = det->getDigitizedData();
 
        for (size_t i = 0; i < truthHits.size(); ++i) {
            if (!truthHits[i]) log->info(0, "VALIDATION: detector <", sdName, "> truth hit ", i, " is null.");
        }
        for (size_t i = 0; i < digiHits.size(); ++i) {
            if (!digiHits[i]) log->info(0, "VALIDATION: detector <", sdName, "> digitized hit ", i, " is null.");
        }
 
        // Matching truth and digitized counts are often expected by example producers, even though the API allows them to differ.
        if (truthHits.size() != digiHits.size()) {
            log->info(0, "VALIDATION: detector <", sdName, "> truthHits(", truthHits.size(),
                      ") != digitizedHits(", digiHits.size(), ") in event ", edc->getEventNumber());
        }
    }
}

static auto run_simulation_in_threads(int                              nevents,
                                      int                              nthreads,
                                      const std::shared_ptr<GOptions>& gopt,
                                      const std::shared_ptr<GLogger>&  log)
    -> std::vector<std::shared_ptr<GEventDataCollection>> {
    std::mutex                                         collectorMtx;
    std::vector<std::shared_ptr<GEventDataCollection>> collected;
    collected.reserve(static_cast<size_t>(nevents));
 
    // Thread-safe event counter local to this example run.
    std::atomic<int> next{1};
 
    // Thread pool. The alias joins on destruction.
    std::vector<jthread_alias> pool;
    pool.reserve(nthreads);
 
    for (int tid = 0; tid < nthreads; ++tid) {
        pool.emplace_back([&, tid] {
            log->info(0, "worker ", tid, " started");
 
            int localCount = 0;
 
            // Thread-local staging buffer reduces lock contention on the shared collector vector.
            thread_local std::vector<std::shared_ptr<GEventDataCollection>> localEvents;
            localEvents.clear();
 
            while (true) {
                int evn = next.fetch_add(1, std::memory_order_relaxed);
                if (evn > nevents) { break; }
 
                // Create one event container. The factory inserts one dummy hit for detector "ctof".
                auto edc = GEventDataCollection::create(gopt);
 
                // Extend the event so the example exercises more than the minimal factory path.
 
                // Add a second hit under the existing detector key.
                edc->addDetectorDigitizedData("ctof", GDigitizedData::create(gopt));
                edc->addDetectorTrueInfoData("ctof", GTrueInfoData::create(gopt));
 
                // Add a second detector with one hit pair.
                edc->addDetectorDigitizedData("ec", GDigitizedData::create(gopt));
                edc->addDetectorTrueInfoData("ec", GTrueInfoData::create(gopt));
 
                localEvents.emplace_back(edc);
                ++localCount;
            }
 
            {
                std::scoped_lock lk(collectorMtx);
                for (auto& evt : localEvents) { collected.emplace_back(evt); }
                localEvents.clear();
            }
 
            log->info(0, "worker ", tid, " processed ", localCount, " events");
        });
    }
 
    return collected;
}

int main(int argc, char* argv[]) {
    // Aggregate options for event-level data collection.
    auto gopts = std::make_shared<GOptions>(argc, argv, gevent_data::defineOptions());
 
    // Event-data logger.
    auto log = std::make_shared<GLogger>(gopts, SFUNCTION_NAME, GEVENTDATA_LOGGER);
 
    // Keep these small by default so the example output remains readable.
    constexpr int nevents  = 5;
    constexpr int nthreads = 4;
 
    auto events = run_simulation_in_threads(nevents, nthreads, gopts, log);
 
    // Inspect and validate each generated event container.
    for (const auto& edc : events) {
        if (!edc) continue;
        validate_event_structure(edc, log);
        dump_event(edc, log);
    }
 
    log->info(0, "Generated ", events.size(), " event containers.");
 
    return EXIT_SUCCESS;
}