gDigitizedData.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <map>
#include <ostream>
#include <string>
#include <vector>
 
// gemc
#include <gemc/gbase/gbase.h>
#include <gemc/ghit/ghit.h>
 
// gdata
#include "gdataConventions.h"
 
constexpr const char* GDIGITIZED_DATA_LOGGER = "digitized_data";
 
namespace gdigi_data {
 
inline GOptions defineOptions() {
    auto goptions = GOptions(GDIGITIZED_DATA_LOGGER);
    return goptions;
}
 
} // namespace gdigi_data
 
class GDigitizedData : public GBase<GDigitizedData>
{
public:
    GDigitizedData(const std::shared_ptr<GOptions>& gopts, const GHit* ghit);
 
    void includeVariable(const std::string& vname, int value);
 
    void includeVariable(const std::string& vname, double value);
 
    void includeTransientVariable(const std::string& vname, double value);
 
    [[nodiscard]] bool hasTransientVariable(const std::string& vname) const;
 
    [[nodiscard]] double getTransientVariable(const std::string& vname) const;
 
    void accumulateVariable(const std::string& vname, int value);
 
    void accumulateVariable(const std::string& vname, double value);
 
    [[nodiscard]] std::map<std::string, int> getIntObservablesMap(int which) const;
 
    [[nodiscard]] std::map<std::string, double> getDblObservablesMap(int which) const;
 
    int getTimeAtElectronics();
 
    int getIntObservable(const std::string& varName);
 
    double getDblObservable(const std::string& varName);
 
    [[nodiscard]] inline std::map<std::string, std::vector<int>> getArrayIntObservablesMap() const {
        return arrayIntObservablesMap;
    }
 
    [[nodiscard]] inline std::map<std::string, std::vector<double>> getArrayDblObservablesMap() const {
        return arrayDoubleObservablesMap;
    }
 
    [[nodiscard]] inline const std::vector<GIdentifier>& getIdentity() const { return gidentity; }
 
    static std::unique_ptr<GDigitizedData> create(const std::shared_ptr<GOptions>& gopts) {
        auto hit       = GHit::create(gopts);
        auto digi_data = std::make_unique<GDigitizedData>(gopts, hit);
        auto counter   = globalDigitizedDataCounter.fetch_add(1, std::memory_order_relaxed);
 
        digi_data->includeVariable(CRATESTRINGID, counter % 10);
        digi_data->includeVariable(SLOTSTRINGID, counter % 20);
        digi_data->includeVariable(CHANNELSTRINGID, counter);
        digi_data->includeVariable(TIMEATELECTRONICS, counter * 5);
        digi_data->includeVariable("adc", counter * 0.1);
        return digi_data;
    }
 
private:
    std::map<std::string, int> intObservablesMap;
 
    std::map<std::string, double> doubleObservablesMap;
 
    std::map<std::string, double> transientVariablesMap;
 
    std::map<std::string, std::vector<int>> arrayIntObservablesMap;
 
    std::map<std::string, std::vector<double>> arrayDoubleObservablesMap;
 
    std::vector<GIdentifier> gidentity;
 
    [[nodiscard]] static bool validVarName(const std::string& varName, int which);
 
    static std::atomic<int> globalDigitizedDataCounter;
 
protected:
    friend std::ostream& operator<<(std::ostream& os, const GDigitizedData& data);
};