gtouchable.cc

Go to the documentation of this file.

// gtouchable
#include "gtouchable.h"
#include "gtouchableConventions.h"
 
// gemc
#include "gutilities.h"
#include "gutsConventions.h"
 
// See header for API docs.
 
// constructor from gopt, digitization and gidentity strings
// called in GDetectorConstruction::ConstructSDandField
GTouchable::GTouchable(const std::shared_ptr<GOptions>& gopt,
                       const std::string&               digitization,
                       const std::string&               gidentityString,
                       const std::vector<double>&       dimensions,
                       const double&                    dm) :
    GBase(gopt, TOUCHABLE_LOGGER),
    trackId(0),
    eMultiplier(1),
    detectorDimensions(dimensions),
    mass(dm) {
    // Determine the type based on the digitization string.
    // The string constants are defined in gtouchableConventions.h.
    if (digitization == gtouchable::FLUXNAME) { gType = flux; }
    else if (digitization == gtouchable::GPHOTON_DETECTORNAME) { gType = gPhotonDetector; }
    else if (digitization == gtouchable::COUNTERNAME) { gType = particle_counter; }
    else if (digitization == gtouchable::DOSIMETERNAME) { gType = dosimeter; }
    else { gType = readout; }
 
    // Parse the gidentity string into (name,value) pairs.
    // Expected format: "sector: 2, layer: 4, wire: 33"
    // The identity vector order is preserved because comparisons assume the same schema/order.
    std::vector<std::string> identity = gutilities::getStringVectorFromStringWithDelimiter(gidentityString, ",");
    // Process each identifier token (e.g., "sector: 2").
    for (auto& gid : identity) {
        std::vector<std::string> identifier = gutilities::getStringVectorFromStringWithDelimiter(gid, ":");
 
        // The parser assumes the token splits into [name, value].
        // Note: In production, consider adding try-catch here to handle conversion errors.
        const std::string& idName  = identifier[0];
        int                idValue = std::stoi(identifier[1]);
 
        gidentity.emplace_back(idName, idValue);
    }
    log->debug(CONSTRUCTOR, "GTouchable%1 %2", gtouchable::to_string(gType), getIdentityString());
}
 
// constructor from logger, digitization and gidentity strings
// called in GDetectorConstruction::ConstructSDandField
GTouchable::GTouchable(const std::shared_ptr<GLogger>& logger,
                       const std::string&              digitization,
                       const std::string&              gidentityString,
                       const std::vector<double>&      dimensions,
                       const double&                   dm) :
    GBase(logger),
    trackId(0),
    eMultiplier(1),
    detectorDimensions(dimensions),
    mass(dm) {
    // Determine the type based on the digitization string.
    // The string constants are defined in gtouchableConventions.h.
    if (digitization == gtouchable::FLUXNAME) { gType = flux; }
    else if (digitization == gtouchable::GPHOTON_DETECTORNAME) { gType = gPhotonDetector; }
    else if (digitization == gtouchable::COUNTERNAME) { gType = particle_counter; }
    else if (digitization == gtouchable::DOSIMETERNAME) { gType = dosimeter; }
    else { gType = readout; }
 
    // Parse the gidentity string into (name,value) pairs.
    // Expected format: "sector: 2, layer: 4, wire: 33"
    // The identity vector order is preserved because comparisons assume the same schema/order.
    std::vector<std::string> identity = gutilities::getStringVectorFromStringWithDelimiter(gidentityString, ",");
    // Process each identifier token (e.g., "sector: 2").
    for (auto& gid : identity) {
        std::vector<std::string> identifier = gutilities::getStringVectorFromStringWithDelimiter(gid, ":");
 
        // The parser assumes the token splits into [name, value].
        // Note: In production, consider adding try-catch here to handle conversion errors.
        const std::string& idName  = identifier[0];
        int                idValue = std::stoi(identifier[1]);
 
        gidentity.emplace_back(idName, idValue);
    }
    log->debug(CONSTRUCTOR, "GTouchable%1 %2", gtouchable::to_string(gType), getIdentityString());
}
 
// Overloaded "==" operator for the class 'GTouchable'
bool GTouchable::operator==(const GTouchable& that) const {
    // First, check if both gidentity vectors are the same size.
    // this should never happen because the same sensitivity should be assigned the same identifier structure
    if (this->gidentity.size() != that.gidentity.size()) {
        log->debug(NORMAL, "Touchable sizes are different");
        return false;
    }
 
    // Compare identifiers positionally.
    // Only the identifier values are compared (schema/order is assumed identical for the same sensitivity).
    log->debug(NORMAL, "  + Touchable comparison:  ");
    for (size_t i = 0; i < this->gidentity.size(); ++i) {
        bool        equal            = ( this->gidentity[i].getValue() == that.gidentity[i].getValue() );
        std::string comparisonResult = equal ? " ✅" : " ❌";
        log->debug(NORMAL, "     ← %1   → %2%3", this->gidentity[i], that.gidentity[i], comparisonResult);
        if (!equal) { return false; }
    }
 
    bool        typeComparison = false;
    std::string result;
 
    // All identity values matched; apply the type-specific discriminator.
    switch (this->gType) {
        case readout:
            typeComparison = this->stepTimeAtElectronicsIndex == that.stepTimeAtElectronicsIndex;
            result = typeComparison ? " ✅" : " ❌";
            log->debug(
                NORMAL, "    Touchable type is readout. Time cell comparison: %1 %2 result:%3",
                this->stepTimeAtElectronicsIndex.value_or(-1), that.stepTimeAtElectronicsIndex.value_or(-1),
                result);
            break;
        case flux:
            typeComparison = this->trackId == that.trackId;
            result = typeComparison ? " ✅" : " ❌";
            log->debug(
                NORMAL, "    Touchable type is flux. Track id comparison: %1 %2 result:%3", this->trackId,
                that.trackId, result);
            break;
        case gPhotonDetector:
            typeComparison = this->trackId == that.trackId;
            result = typeComparison ? " ✅" : " ❌";
            log->debug(
                NORMAL, "    Touchable type is gPhotonDetector. Track id comparison: %1 %2 result:%3",
                this->trackId, that.trackId, result);
            break;
        case dosimeter:
            typeComparison = true;
            log->debug(
                NORMAL, "    Touchable type is dosimeter. No additional comparison needed, returning true ✅");
            break;
 
        case particle_counter:
            typeComparison = this->pid == that.pid;
            result = typeComparison ? " ✅" : " ❌";
            log->debug(
                NORMAL, "    Touchable type is flux. Track id comparison: %1 %2 result:%3", this->trackId,
                that.trackId, result);
            break;
 
        case integral_counter:
            typeComparison = true;
            log->debug(
                NORMAL,
                "    Touchable type is integral_counter. No additional comparison needed, returning true ✅");
            break;
    }
    return typeComparison;
}
 
// Builds the hit-cell key with the same semantics as operator==: identity values plus the
// type-specific discriminator. Kept allocation-light because it runs for every step in a
// sensitive volume.
std::string GTouchable::cellKey() const {
    std::string key;
    key.reserve(gidentity.size() * 8 + 12);
    for (const auto& gid : gidentity) {
        key += std::to_string(gid.getValue());
        key += ',';
    }
    switch (gType) {
        case readout:
            key += 'r';
            key += stepTimeAtElectronicsIndex ? std::to_string(*stepTimeAtElectronicsIndex) : "unset";
            break;
        case flux:
        case gPhotonDetector: key += 't'; key += std::to_string(trackId); break;
        case particle_counter: key += 'p'; key += std::to_string(pid); break;
        case dosimeter:
        case integral_counter: break;
    }
    return key;
}
 
// ostream GTouchable
std::ostream& operator<<(std::ostream& stream, const GTouchable& gtouchable) {
    stream << " GTouchable: ";
    for (auto& gid : gtouchable.gidentity) {
        stream << guts::KRED << gid;
        if (gid.getName() != gtouchable.gidentity.back().getName()) { stream << ", "; }
        else { stream << guts::RST; }
    }
    switch (gtouchable.gType) {
        case readout:
            // compare the time cell
            stream << guts::KGRN << " (readout), " << guts::RST << " multiplier: " << gtouchable.eMultiplier <<
                ", time cell index: " <<
                (gtouchable.stepTimeAtElectronicsIndex
                     ? std::to_string(*gtouchable.stepTimeAtElectronicsIndex)
                     : "unset");
            break;
        case flux:
            stream << guts::KGRN << " (flux), " << guts::RST << " g4 track id: " << gtouchable.trackId;
            break;
        case gPhotonDetector:
            stream << guts::KGRN << " (gPhotonDetector), " << guts::RST << " g4 track id: " << gtouchable.trackId;
            break;
        case dosimeter:
            stream << guts::KGRN << " (dosimeter), " << guts::RST;
            break;
        case particle_counter:
            stream << guts::KGRN << " (particle_counter), " << guts::RST << " particle id: " << gtouchable.pid;
            break;
        case integral_counter:
            stream << guts::KGRN << " (integral_counter), " << guts::RST;
            break;
    }
 
    return stream;
}

std::ostream& operator<<(std::ostream& stream, const GIdentifier& gidentifier) {
    stream << gidentifier.idName << ": " << gidentifier.idValue;
    return stream;
}