gdynamicdigitization.cc

Go to the documentation of this file.

 
#include "gdynamicdigitization.h"
 
// gemc
#include "gtranslationTableConventions.h"
#include "gdataConventions.h"
#include "gtouchableConventions.h"
 
// c++
#include <iostream>
 
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();
 
    // Loop over all identities and include them in the true info data.
    for (auto& identity : identities) { trueInfoData->includeVariable(identity.getName(), identity.getValue()); }
 
    // Process bit 0: always present values.
    ghit->calculateInfosForBit(0);
    G4ThreeVector avgGlobalPos = ghit->getAvgGlobaPosition();
    G4ThreeVector avgLocalPos  = ghit->getAvgLocalPosition();
 
    trueInfoData->includeVariable("totalEDeposited", ghit->getTotalEnergyDeposited());
    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("hitn", static_cast<int>(hitn)); // reasonable to assume hitn is less than INT_MAX
 
    // Process bit 1: include process name.
    trueInfoData->includeVariable("processName", ghit->getProcessName());
 
    return trueInfoData;
}
 
void GDynamicDigitization::chargeAndTimeAtHardware(int time, int q, const GHit* ghit, GDigitizedData& gdata) {
    check_if_log_defined();
    // Exit if the translation table is not defined.
    if (translationTable == nullptr) {
        log->error(EC__TTNOTFOUNDINTT, "Translation Table not found");
    }
    else {
        // Obtain the hardware address (crate, slot, channel) from the translation table.
        std::vector<int> haddress = translationTable->getElectronics(ghit->getTTID()).getHAddress();
        // Exit if the hardware address is not properly initialized.
        if (haddress.front() == UNINITIALIZEDNUMBERQUANTITY) {
            log->error(EC__GIDENTITYNOTFOUNDINTT, "Translation Table found, but haddress was not initialized");
        }
        else {
            // Include hardware address, time, and charge in the digitized data.
            gdata.includeVariable(CRATESTRINGID, haddress[0]);
            gdata.includeVariable(SLOTSTRINGID, haddress[1]);
            gdata.includeVariable(CHANNELSTRINGID, haddress[2]);
            gdata.includeVariable(TIMEATELECTRONICS, time);
            gdata.includeVariable(CHARGEATELECTRONICS, q);
        }
    }
}
 
GTouchableModifiers::GTouchableModifiers(const std::vector<std::string>& touchableNames) { for (const auto& tname : touchableNames) { modifierWeightsMap[tname] = {}; } }
 
void GTouchableModifiers::insertIdAndWeight(const std::string& touchableName, int idValue, double weight) {
    modifierWeightsMap[touchableName].push_back(idValue);
    modifierWeightsMap[touchableName].push_back(weight);
}
 
void GTouchableModifiers::insertIdWeightAndTime(const std::string& touchableName, int idValue, double weight, double time) {
    modifierWeightsAndTimesMap[touchableName].push_back(idValue);
    modifierWeightsAndTimesMap[touchableName].push_back(weight);
    modifierWeightsAndTimesMap[touchableName].push_back(time);
}
 
void GTouchableModifiers::assignOverallWeight(const std::string& tname, double totalWeight) {
    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; }
    size_t countWeightsAndTimes = modifierWeightsAndTimesMap[tname].size() / 3; // Triplets: (id, weight, time)
    for (size_t h = 0; h < countWeightsAndTimes; h++) {
        // Normalize the weight in each triplet (index: h*3 + 1).
        modifierWeightsAndTimesMap[tname][h * 3 + 1] = modifierWeightsAndTimesMap[tname][h * 3 + 1] / totalWeight;
    }
}
 
double GDynamicDigitization::processStepTimeImpl([[maybe_unused]] const std::shared_ptr<GTouchable>& gTouchID, [[maybe_unused]] G4Step* thisStep) {
    return thisStep->GetPostStepPoint()->GetGlobalTime();
}
 
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 (stepTimeAtElectronicsIndex == gtouchable->getStepTimeAtElectronicsIndex() ||
        gtouchable->getStepTimeAtElectronicsIndex() == GTOUCHABLEUNSETTIMEINDEX) {
        gtouchable->assignStepTimeAtElectronicsIndex(stepTimeAtElectronicsIndex);
 
        result.emplace_back(gtouchable);
    }
    else {
        // Create a new GTouchable with the updated time index.
        auto cloned = std::make_shared<GTouchable>(gtouchable, stepTimeAtElectronicsIndex);
 
        // release ownership of the original touchable and return both.
        // std::initializer_list requires copyable elements, so we need to create the vector first
        result.emplace_back(gtouchable);
        result.emplace_back(cloned);
    }
 
    return result;
}
 
// TODO: are we using this anywhere? pass readonly touchId or move it?
std::vector<std::shared_ptr<GTouchable>> GDynamicDigitization::processGTouchableModifiersImpl([[maybe_unused]] const std::shared_ptr<GTouchable>& gTouchID,
                                                                                              [[maybe_unused]] const GTouchableModifiers&         gmods) {
    std::vector<std::shared_ptr<GTouchable>> touchables;
 
    // touchables.emplace_back(std::make_unique<GTouchable>(*gTouchID, 1)); // Ensure we have a valid touchable to return
 
    return touchables;
}