gdynamicdigitization.cc

Go to the documentation of this file.

 
#include "gdynamicdigitization.h"
#include "gdynamicdigitizationConventions.h"
 
// gemc
#include "gtranslationTableConventions.h"
#include "gdataConventions.h"
#include "gtouchableConventions.h"
#include "gutsConventions.h"
#include "gutilities.h"
 
// c++
#include <algorithm>
 
namespace {
 
// Returns true when systemName (or "all") appears in the option's whitespace- or comma-separated list.
// An absent or empty option matches nothing.
bool system_in_rejection_list(const std::shared_ptr<GOptions>& gopts, const std::string& option,
                              const std::string& systemName) {
    auto list_option = gopts->getOptionalScalarString(option);
    if (!list_option || list_option->empty()) { return false; }
    std::string list = std::move(*list_option);
    std::replace(list.begin(), list.end(), ',', ' ');
    for (const auto& name : gutilities::getStringVectorFromString(list)) {
        if (name == "all" || name == systemName) { return true; }
    }
    return false;
}
 
} // namespace
 
 
// See header for API docs.
std::unique_ptr<GTrueInfoData> GDynamicDigitization::collectTrueInformationImpl(GHit* ghit, size_t hitn) {
    auto trueInfoData = std::make_unique<GTrueInfoData>(gopts, ghit);
 
    std::vector<GIdentifier> identities = ghit->getGID();
 
    // Average positions are computed at the hit level by GHit and returned here.
    G4ThreeVector avgGlobalPos = ghit->getAvgGlobalPosition();
    G4ThreeVector avgLocalPos  = ghit->getAvgLocalPosition();
    G4ThreeVector trackVertex = ghit->getTrackVertexPosition();
    const auto&   motherInfo = ghit->getMotherInfo();
    const auto    missingMotherVertex = G4ThreeVector(
        MISSING_TRUE_INFORMATION_NUMBER,
        MISSING_TRUE_INFORMATION_NUMBER,
        MISSING_TRUE_INFORMATION_NUMBER);
    const G4ThreeVector motherTrackVertex = motherInfo.vertex.value_or(missingMotherVertex);
 
    trueInfoData->includeVariable("pid", ghit->getPid());
    trueInfoData->includeVariable("mpid", motherInfo.pid.value_or(MISSING_TRUE_INFORMATION_NUMBER));
    trueInfoData->includeVariable("tid", ghit->getTid());
    trueInfoData->includeVariable("otid", 0);
    trueInfoData->includeVariable("opid", 0);
    trueInfoData->includeVariable("opx", 0.0);
    trueInfoData->includeVariable("opy", 0.0);
    trueInfoData->includeVariable("opz", 0.0);
    trueInfoData->includeVariable("mtid", motherInfo.trackId);
    trueInfoData->includeVariable("totalEDeposited", ghit->getTotalEnergyDeposited());
    trueInfoData->includeVariable("trackE", ghit->getTrackE());
    trueInfoData->includeVariable("avgTime", ghit->getAverageTime());
    trueInfoData->includeVariable("avgx", avgGlobalPos.getX());
    trueInfoData->includeVariable("avgy", avgGlobalPos.getY());
    trueInfoData->includeVariable("avgz", avgGlobalPos.getZ());
    trueInfoData->includeVariable("avglx", avgLocalPos.getX());
    trueInfoData->includeVariable("avgly", avgLocalPos.getY());
    trueInfoData->includeVariable("avglz", avgLocalPos.getZ());
    trueInfoData->includeVariable("vx", trackVertex.getX());
    trueInfoData->includeVariable("vy", trackVertex.getY());
    trueInfoData->includeVariable("vz", trackVertex.getZ());
    trueInfoData->includeVariable("mvx", motherTrackVertex.getX());
    trueInfoData->includeVariable("mvy", motherTrackVertex.getY());
    trueInfoData->includeVariable("mvz", motherTrackVertex.getZ());
 
    G4ThreeVector momentum = ghit->getMomentum();
    trueInfoData->includeVariable("px", momentum.getX());
    trueInfoData->includeVariable("py", momentum.getY());
    trueInfoData->includeVariable("pz", momentum.getZ());
 
    trueInfoData->includeVariable("nsteps", static_cast<int>(ghit->getStepCount()));
    trueInfoData->includeVariable("nphotons", static_cast<int>(ghit->getNumberOfOpticalPhotons()));
    trueInfoData->includeVariable("hitn", static_cast<int>(hitn)); // assume hitn < INT_MAX
 
    const std::string processName = ghit->getProcessName().value_or(guts::SERIALIZED_NULL_TOKEN);
    trueInfoData->includeVariable("processName", processName);
    trueInfoData->includeVariable("procID", processName);
 
    return trueInfoData;
}
 
// See header for API docs.
void GDynamicDigitization::chargeAndTimeAtHardware(int time, int q, const GHit* ghit, GDigitizedData& gdata) {
    check_if_log_defined();
 
    if (translationTable == nullptr) {
        log->error(gtranslationTable::EC__TTNOTFOUNDINTT, "Translation Table not found");
    }
 
    // Translate a TT id into a crate/slot/channel triple.
    const GElectronic& electronics = translationTable->getElectronics(ghit->getTTID());
    std::vector<int> haddress = electronics.getHAddress();
 
    gdata.includeVariable(CRATESTRINGID, haddress[0]);
    gdata.includeVariable(SLOTSTRINGID, haddress[1]);
    gdata.includeVariable(CHANNELSTRINGID, haddress[2]);
    gdata.includeVariable(TIMEATELECTRONICS, time);
    gdata.includeVariable(CHARGEATELECTRONICS, q);
}
 
// See header for API docs.
GTouchableModifiers::GTouchableModifiers(const std::vector<std::string>& touchableNames) {
    // Pre-declare keys so later access is well-defined for known touchables.
    for (const auto& tname : touchableNames) {
        modifierWeightsMap[tname] = {};
    }
}
 
// See header for API docs.
void GTouchableModifiers::insertIdAndWeight(const std::string& touchableName, int idValue, double weight) {
    // Stored as a flat vector: (id, weight, id, weight, ...)
    modifierWeightsMap[touchableName].push_back(idValue);
    modifierWeightsMap[touchableName].push_back(weight);
}
 
// See header for API docs.
void GTouchableModifiers::insertIdWeightAndTime(const std::string& touchableName, int idValue, double weight,
                                                double             time) {
    // Stored as a flat vector: (id, weight, time, id, weight, time, ...)
    modifierWeightsAndTimesMap[touchableName].push_back(idValue);
    modifierWeightsAndTimesMap[touchableName].push_back(weight);
    modifierWeightsAndTimesMap[touchableName].push_back(time);
}
 
// See header for API docs.
void GTouchableModifiers::assignOverallWeight(const std::string& tname, double totalWeight) {
    // Normalize (id, weight) pairs.
    size_t countWeights = modifierWeightsMap[tname].size() / 2;
    for (size_t h = 0; h < countWeights; h++) {
        modifierWeightsMap[tname][h * 2 + 1] = modifierWeightsMap[tname][h * 2 + 1] / totalWeight;
    }
 
    // Normalize (id, weight, time) triplets.
    size_t countWeightsAndTimes = modifierWeightsAndTimesMap[tname].size() / 3;
    for (size_t h = 0; h < countWeightsAndTimes; h++) {
        modifierWeightsAndTimesMap[tname][h * 3 + 1] = modifierWeightsAndTimesMap[tname][h * 3 + 1] / totalWeight;
    }
}
 
// See header for API docs.
double GDynamicDigitization::processStepTimeImpl([[maybe_unused]] const std::shared_ptr<GTouchable>& gTouchID,
                                                 [[maybe_unused]] G4Step*                            thisStep) {
    // Default time definition: global time of the post-step point.
    return thisStep->GetPostStepPoint()->GetGlobalTime();
}
 
// See header for API docs.
std::vector<std::shared_ptr<GTouchable>> GDynamicDigitization::processTouchableImpl(
    std::shared_ptr<GTouchable> gtouchable, G4Step* thisStep) {
    double stepTimeAtElectronics      = processStepTime(gtouchable, thisStep);
    int    stepTimeAtElectronicsIndex = readoutSpecs->timeCellIndex(stepTimeAtElectronics);
 
    std::vector<std::shared_ptr<GTouchable>> result;
 
    // If the touchable does not yet have a time index, or it matches the current step's
    // index, we can reuse it.
    const auto& assignedTimeIndex = gtouchable->getStepTimeAtElectronicsIndex();
    if (!assignedTimeIndex || stepTimeAtElectronicsIndex == *assignedTimeIndex) {
        gtouchable->assignStepTimeAtElectronicsIndex(stepTimeAtElectronicsIndex);
        result.emplace_back(gtouchable);
    }
    else {
        // Otherwise, create a cloned touchable with the new time index and return both.
        auto cloned = std::make_shared<GTouchable>(gtouchable, stepTimeAtElectronicsIndex);
 
        // std::initializer_list requires copyable elements, so build the vector explicitly.
        result.emplace_back(gtouchable);
        result.emplace_back(cloned);
    }
 
    return result;
}
 
// See header for API docs.
std::vector<std::shared_ptr<GTouchable>> GDynamicDigitization::processGTouchableModifiersImpl(
    [[maybe_unused]] const std::shared_ptr<GTouchable>& gTouchID,
    [[maybe_unused]] const GTouchableModifiers&         gmods) {
    // Default behavior: no modifier processing.
    std::vector<std::shared_ptr<GTouchable>> touchables;
    return touchables;
}
 
// See header for API docs.
void GDynamicDigitization::setHitRejectionPolicies(const std::string& systemName) {
    applyThresholds_     = system_in_rejection_list(gopts, "applyThresholds", systemName);
    applyInefficiencies_ = system_in_rejection_list(gopts, "applyInefficiencies", systemName);
}