gDataCollection.h

Go to the documentation of this file.

#pragma once
 
#include "gDigitizedData.h"
#include "gTrueInfoData.h"
 
// c++
#include <memory>
#include <ostream>
#include <vector>
 
class GDataCollection
{
public:
    explicit GDataCollection() = default;
 
    ~GDataCollection() = default;
 
    void collectTrueInfosData(const std::unique_ptr<GTrueInfoData>& data) {
        // The first integrated contribution creates the detector-local accumulator entry.
        if (trueInfosData.empty()) {
            trueInfosData.push_back(std::make_unique<GTrueInfoData>(*data));
        }
        else {
            // Subsequent contributions add only numeric observables into the first stored entry.
            for (const auto& [varName, value] : data->getDoubleVariablesMap()) {
                trueInfosData.front()->accumulateVariable(varName, value);
            }
        }
    }
 
    void collectDigitizedData(const std::unique_ptr<GDigitizedData>& data) {
        // The first integrated contribution creates the detector-local accumulator entry.
        if (digitizedData.empty()) {
            digitizedData.push_back(std::make_unique<GDigitizedData>(*data));
        }
        else {
            // Only non-SRO scalar observables are accumulated in integrated mode.
            for (const auto& [varName, value] : data->getIntObservablesMap(0)) {
                digitizedData.front()->accumulateVariable(varName, value);
            }
            for (const auto& [varName, value] : data->getDblObservablesMap(0)) {
                digitizedData.front()->accumulateVariable(varName, value);
            }
        }
    }
 
    void addDigitizedData(std::unique_ptr<GDigitizedData> data) {
        // Event-mode insertion appends the new hit object and transfers ownership into the container.
        digitizedData.push_back(std::move(data));
    }
 
    void addTrueInfoData(std::unique_ptr<GTrueInfoData> data) {
        // Event-mode insertion appends the new hit object and transfers ownership into the container.
        trueInfosData.push_back(std::move(data));
    }
 
    [[nodiscard]] auto getTrueInfoData() const -> const std::vector<std::unique_ptr<GTrueInfoData>>& {
        return trueInfosData;
    }
 
    [[nodiscard]] auto getDigitizedData() const -> const std::vector<std::unique_ptr<GDigitizedData>>& {
        return digitizedData;
    }
 
    [[nodiscard]] auto getMutableDigitizedData() -> std::vector<std::unique_ptr<GDigitizedData>>& {
        return digitizedData;
    }
 
private:
    std::vector<std::unique_ptr<GTrueInfoData>> trueInfosData;
 
    std::vector<std::unique_ptr<GDigitizedData>> digitizedData;
 
protected:
    friend std::ostream& operator<<(std::ostream& os, const GDataCollection& collection) {
        os << "GDataCollection{";
 
        os << "trueInfosData=[";
        for (size_t i = 0; i < collection.trueInfosData.size(); ++i) {
            if (i != 0) {
                os << ", ";
            }
            if (collection.trueInfosData[i]) {
                os << *collection.trueInfosData[i];
            }
            else {
                os << "null";
            }
        }
        os << "]";
 
        os << ", digitizedData=[";
        for (size_t i = 0; i < collection.digitizedData.size(); ++i) {
            if (i != 0) {
                os << ", ";
            }
            if (collection.digitizedData[i]) {
                os << *collection.digitizedData[i];
            }
            else {
                os << "null";
            }
        }
        os << "]";
 
        os << "}";
        return os;
    }
};