gDigitizedData.cc

Go to the documentation of this file.

 
#include "gDigitizedData.h"
#include "gdataConventions.h"
 
// c++
#include <map>
#include <string>
#include <vector>
 
#include <gemc/gdynamicDigitization/gdynamicdigitization_options.h>
 
// Thread-safe counter used only by the example/test factory create().
std::atomic<int> GDigitizedData::globalDigitizedDataCounter{0};
 
GDigitizedData::GDigitizedData(const std::shared_ptr<GOptions>& gopts, const GHit* ghit)
    : GBase(gopts, GDIGITIZED_DATA_LOGGER) {
    // Copy the hit identity so this object remains self-contained after the source hit expires.
    gidentity = ghit->getGID();
}
 
std::map<std::string, int> GDigitizedData::getIntObservablesMap(int which) const {
    // Return a filtered snapshot of the stored integer observables.
    std::map<std::string, int> filteredIntObservablesMap;
    for (const auto& [varName, value] : intObservablesMap) {
        if (validVarName(varName, which)) { filteredIntObservablesMap[varName] = value; }
    }
    log->info(2, " getting %1 from intObservablesMap.", which);
    return filteredIntObservablesMap;
}
 
std::map<std::string, double> GDigitizedData::getDblObservablesMap(int which) const {
    // Return a filtered snapshot of the stored floating-point observables.
    std::map<std::string, double> filteredDblObservablesMap;
    for (const auto& [varName, value] : doubleObservablesMap) {
        if (validVarName(varName, which)) { filteredDblObservablesMap[varName] = value; }
    }
    log->info(2, " getting %1 from doubleObservablesMap.", which);
    return filteredDblObservablesMap;
}
 
bool GDigitizedData::validVarName(const std::string& varName, int which) {
    // Classify variables as SRO or non-SRO using the conventional names from gdataConventions.h.
    bool isSROVar = (varName == CRATESTRINGID || varName == SLOTSTRINGID || varName == CHANNELSTRINGID ||
                     varName == CHARGEATELECTRONICS || varName == TIMEATELECTRONICS);
 
    // which == 0 means the caller wants non-SRO variables only.
    if (which == 0) {
        if (isSROVar) { return false; }
    }
    // which == 1 means the caller wants SRO variables only.
    else if (which == 1) {
        if (!isSROVar) { return false; }
    }
 
    // Any other selector currently behaves like "no additional filtering".
    return true;
}
 
void GDigitizedData::includeVariable(const std::string& vname, int value) {
    // Event-level insertion with overwrite semantics.
    log->info(2, "Including int variable %1 with value %2", vname, value);
    intObservablesMap[vname] = value;
}
 
void GDigitizedData::includeVariable(const std::string& vname, double value) {
    // Event-level insertion with overwrite semantics.
    log->info(2, "Including double variable %1 with value %2", vname, value);
    doubleObservablesMap[vname] = value;
}
 
void GDigitizedData::includeTransientVariable(const std::string& vname, double value) {
    log->info(2, "Including transient variable %1 with value %2", vname, value);
    transientVariablesMap[vname] = value;
}
 
bool GDigitizedData::hasTransientVariable(const std::string& vname) const {
    return transientVariablesMap.contains(vname);
}
 
double GDigitizedData::getTransientVariable(const std::string& vname) const {
    return transientVariablesMap.at(vname);
}
 
void GDigitizedData::accumulateVariable(const std::string& vname, int value) {
    // Run/integrated accumulation by summation.
    if (!intObservablesMap.contains(vname)) {
        log->info(2, "Accumulating new int variable %1 with value %2", vname, value);
        intObservablesMap[vname] = value;
    }
    else {
        log->info(2, "Accumulating int variable %1 with value %2", vname, value);
        intObservablesMap[vname] += value;
    }
}
 
void GDigitizedData::accumulateVariable(const std::string& vname, double value) {
    // Run/integrated accumulation by summation.
    if (!doubleObservablesMap.contains(vname)) {
        log->info(2, "Accumulating double variable %1 with value %2", vname, value);
        doubleObservablesMap[vname] = value;
    }
    else {
        log->info(2, "Accumulating double variable %1 with value %2", vname, value);
        doubleObservablesMap[vname] += value;
    }
}
 
std::optional<int> GDigitizedData::getTimeAtElectronics() const {
    const auto time = intObservablesMap.find(TIMEATELECTRONICS);
    if (time == intObservablesMap.end()) { return std::nullopt; }
    log->info(2, "Getting TIMEATELECTRONICS from intObservablesMap.");
    return time->second;
}
 
int GDigitizedData::getIntObservable(const std::string& varName) {
    // Retrieve a single integer observable by key.
    if (!intObservablesMap.contains(varName)) {
        log->error(
            ERR_VARIABLENOTFOUND, "variable name <%1> not found in GDigitizedData::intObservablesMap", varName);
    }
    return intObservablesMap[varName];
}
 
double GDigitizedData::getDblObservable(const std::string& varName) {
    // Retrieve a single floating-point observable by key.
    if (!doubleObservablesMap.contains(varName)) {
        log->error(
            ERR_VARIABLENOTFOUND, "variable name <%1> not found in GDigitizedData::doubleObservablesMap",
            varName);
    }
    return doubleObservablesMap[varName];
}
 
 
std::ostream& operator<<(std::ostream& os, const GDigitizedData& data) {
 
    auto idString = getIdentityString(data.gidentity);
 
    os << "GDigitizedData{identity=\"" << idString  << "\"";
 
    if (!data.intObservablesMap.empty()) {
        os << ", intObservables={";
        bool first = true;
        for (const auto& [name, value] : data.intObservablesMap) {
            if (!first) {
                os << ", ";
            }
            os << name << ": " << value;
            first = false;
        }
        os << "}";
    }
 
    if (!data.doubleObservablesMap.empty()) {
        os << ", doubleObservables={";
        bool first = true;
        for (const auto& [name, value] : data.doubleObservablesMap) {
            if (!first) {
                os << ", ";
            }
            os << name << ": " << value;
            first = false;
        }
        os << "}";
    }
 
    if (!data.arrayIntObservablesMap.empty()) {
        os << ", arrayIntObservables={";
        bool firstMap = true;
        for (const auto& [name, values] : data.arrayIntObservablesMap) {
            if (!firstMap) {
                os << ", ";
            }
            os << name << ": [";
            bool firstVal = true;
            for (const auto& value : values) {
                if (!firstVal) {
                    os << ", ";
                }
                os << value;
                firstVal = false;
            }
            os << "]";
            firstMap = false;
        }
        os << "}";
    }
 
    if (!data.arrayDoubleObservablesMap.empty()) {
        os << ", arrayDoubleObservables={";
        bool firstMap = true;
        for (const auto& [name, values] : data.arrayDoubleObservablesMap) {
            if (!firstMap) {
                os << ", ";
            }
            os << name << ": [";
            bool firstVal = true;
            for (const auto& value : values) {
                if (!firstVal) {
                    os << ", ";
                }
                os << value;
                firstVal = false;
            }
            os << "]";
            firstMap = false;
        }
        os << "}";
    }
 
    os << "}";
    return os;
}