gEventHeader.h

Go to the documentation of this file.

#pragma once
 
// gemc
#include "gbase.h"
 
// C++
#include <atomic>
#include <string>
 
constexpr const char* GDATAEVENTHEADER_LOGGER = "event_header";
 
namespace geventheader {
inline GOptions defineOptions() {
    auto goptions = GOptions(GDATAEVENTHEADER_LOGGER);
    return goptions;
}
} // namespace geventheader
 
class GEventHeader : public GBase<GEventHeader>
{
public:
    GEventHeader(const std::shared_ptr<GOptions>& gopts, int n, int tid)
        : GBase(gopts, GDATAEVENTHEADER_LOGGER), g4localEventNumber(n), threadID(tid) {
        timeStamp = assignTimeStamp();
        log->debug(CONSTRUCTOR, "GEventHeader");
        log->info(1, "\n",
                  TPOINTITEM, " Event Number:  ", g4localEventNumber, "\n",
                  TPOINTITEM, " Thread ID:  ", threadID, "\n",
                  TPOINTITEM, " Time Stamp:  ", timeStamp);
    }
 
    static std::unique_ptr<GEventHeader> create(const std::shared_ptr<GOptions>& gopts, int tid = -1) {
        int eventNumber = globalEventHeaderCounter.fetch_add(1, std::memory_order_relaxed);
        int threadID_   = tid;
        if (threadID_ < 0) {
            threadID_ = eventNumber % 8; // default to 8 threads if not provided
        }
        return std::make_unique<GEventHeader>(gopts, eventNumber, threadID_);
    }
 
    [[nodiscard]] inline std::string getTimeStamp() const { return timeStamp; }
 
    [[nodiscard]] inline int getG4LocalEvn() const { return g4localEventNumber; }
 
    [[nodiscard]] inline int getThreadID() const { return threadID; }
 
private:
    int g4localEventNumber; 
    int threadID;           
 
    static std::string assignTimeStamp() {
        time_t     now = time(nullptr);
        struct tm* ptm = localtime(&now);
        char       buffer[32];
        strftime(buffer, 32, "%a %m.%d.%Y %H:%M:%S", ptm);
        return {buffer};
    }
 
    std::string timeStamp; 
 
    static std::atomic<int> globalEventHeaderCounter;
};