gdynamicdigitization.h

Go to the documentation of this file.

#pragma once
 
#include <gemc/gstreamer/sro/gSROData.h>
 
#include "greadoutSpecs.h"
#include <gemc/gfactory/gfactory_options.h>
 
// gemc
#include <gemc/gfactory/gfactory.h>
#include <gemc/gtouchable/gtouchable.h>
#include <gemc/ghit/ghit.h>
#include <gemc/gdata/gDigitizedData.h>
#include <gemc/gdata/gTrueInfoData.h>
#include <gemc/gtranslationTable/gtranslationTable.h>
#include "gdynamicdigitization_options.h"
 
// c++
#include <utility>
#include <vector>
#include <bitset>
#include <map>
#include <string>
#include <optional>
 
// geant4
#include "G4Step.hh"

class GTouchableModifiers {
public:
    explicit GTouchableModifiers(const std::vector<std::string> &touchableNames);
 
private:
    std::map<std::string, std::vector<double> > modifierWeightsMap;

    std::map<std::string, std::vector<double> > modifierWeightsAndTimesMap;
 
public:
    void insertIdAndWeight(const std::string &touchableName, int idValue, double weight);

    void insertIdWeightAndTime(const std::string &touchableName, int idValue, double weight, double time);

    void assignOverallWeight(const std::string &touchableName, double totalWeight);

    [[nodiscard]] inline bool isWeightsOnly() const { return !modifierWeightsMap.empty(); }

    inline std::vector<double> getModifierWeightsVector(const std::string &touchableName) {
        return modifierWeightsMap[touchableName];
    }

    inline std::vector<double> getModifierWeightsAndTimeVector(const std::string &touchableName) {
        return modifierWeightsAndTimesMap[touchableName];
    }
};
 
enum CollectionMode {
    event,
    run,
    frame
};
 
inline constexpr const char *to_string(CollectionMode mode) {
    switch (mode) {
        case event: return "event";
        case run: return "run";
        case frame: return "frame";
    }
    return "unknown";
}

class GDynamicDigitization : public GBase<GDynamicDigitization> {
public:
    explicit GDynamicDigitization(const std::shared_ptr<GOptions> &g) : GBase(g, GDIGITIZATION_LOGGER) {
        recordZeroEdep = g->getSwitch("recordZeroEdep");
    }

    ~GDynamicDigitization() override = default;
 
    [[nodiscard]] virtual CollectionMode collection_mode() const { return CollectionMode::event; }

    [[nodiscard]] double processStepTime(const std::shared_ptr<GTouchable> &gTouchID,
                                         [[maybe_unused]] G4Step *thisStep) {
        check_if_log_defined();
        log->debug(NORMAL, FUNCTION_NAME);
        return processStepTimeImpl(gTouchID, thisStep);
    }

    [[nodiscard]] virtual double processStepTimeImpl(const std::shared_ptr<GTouchable> &gTouchID,
                                                     [[maybe_unused]] G4Step *thisStep);
 
    [[nodiscard]] std::vector<std::string> variables_to_normalize() {
        check_if_log_defined();
 
        log->debug(NORMAL, FUNCTION_NAME);
 
        return variables_to_normalizeImpl();
    }
 
 
    [[nodiscard]] virtual std::vector<std::string> variables_to_normalizeImpl() {
        std::vector<std::string> variables;
        return variables;
    }
 

    [[nodiscard]] std::vector<std::shared_ptr<GTouchable> > processTouchable(
        std::shared_ptr<GTouchable> gtouchable, G4Step *thisStep) {
        check_if_log_defined();
        log->debug(NORMAL, FUNCTION_NAME);
        return processTouchableImpl(std::move(gtouchable), thisStep);
    }

    [[nodiscard]] virtual std::vector<std::shared_ptr<GTouchable> > processTouchableImpl(
        std::shared_ptr<GTouchable> gtouchable, G4Step *thisStep);

    [[nodiscard]] std::vector<std::shared_ptr<GTouchable> > processGTouchableModifiers(
        const std::shared_ptr<GTouchable> &gTouchID, const GTouchableModifiers &gmods) {
        check_if_log_defined();
        log->debug(NORMAL, FUNCTION_NAME);
        return processGTouchableModifiersImpl(gTouchID, gmods);
    }

    virtual std::vector<std::shared_ptr<GTouchable> > processGTouchableModifiersImpl(
        [[maybe_unused]] const std::shared_ptr<GTouchable> &gTouchID,
        [[maybe_unused]] const GTouchableModifiers &gmods);

    [[nodiscard]] std::unique_ptr<GTrueInfoData> collectTrueInformation(GHit *ghit, size_t hitn) {
        check_if_log_defined();
        log->info(2, "GDynamicDigitization::collect true information for hit number ", hitn, " with size ",
                  ghit->nsteps(), " steps");
        return collectTrueInformationImpl(ghit, hitn);
    }

    [[nodiscard]] virtual std::unique_ptr<GTrueInfoData> collectTrueInformationImpl(GHit *ghit, size_t hitn);

    [[nodiscard]] std::unique_ptr<GDigitizedData> digitizeHit(GHit *ghit, [[maybe_unused]] size_t hitn) {
        check_if_log_defined();
        log->info(2, "GDynamicDigitization::digitize  hit number ", hitn, " with size ", ghit->nsteps(), " steps");
        return digitizeHitImpl(ghit, hitn);
    }

    [[nodiscard]] virtual std::unique_ptr<GDigitizedData> digitizeHitImpl(
        [[maybe_unused]] GHit *ghit, [[maybe_unused]] size_t hitn) { return nullptr; }

    virtual void stream_hit([[maybe_unused]] GHit* hit, [[maybe_unused]] std::size_t hit_index,
                            [[maybe_unused]] const GSROEventContext& event,
                            [[maybe_unused]] const GSROEmit& emit) const {}

    [[nodiscard]] bool loadConstants([[maybe_unused]] int runno, [[maybe_unused]] std::string const &variation) {
        check_if_log_defined();
        log->debug(NORMAL, "GDynamicDigitization::load constants");
        return loadConstantsImpl(runno, variation);
    }

    virtual bool loadConstantsImpl([[maybe_unused]] int runno, [[maybe_unused]] std::string const &variation) {
        return true;
    }

    [[nodiscard]] bool loadTT([[maybe_unused]] int runno, [[maybe_unused]] std::string const &variation) {
        check_if_log_defined();
        log->debug(NORMAL, "GDynamicDigitization::load Translation Table for run ", runno, " with variation ",
                   variation);
        return loadTTImpl(runno, variation);
    }

    virtual bool loadTTImpl([[maybe_unused]] int runno, [[maybe_unused]] std::string const &variation) { return true; }

    void chargeAndTimeAtHardware(int time, int q, const GHit *ghit, GDigitizedData &gdata);

    [[nodiscard]] bool defineReadoutSpecs() {
        check_if_log_defined();
        log->debug(NORMAL, "GDynamicDigitization::define readout specs");
        return defineReadoutSpecsImpl();
    };

    virtual bool defineReadoutSpecsImpl() = 0;

    std::shared_ptr<const GReadoutSpecs> readoutSpecs;

    std::shared_ptr<const GTranslationTable> translationTable;

    static GDynamicDigitization *instantiate(const dlhandle h, std::shared_ptr<GOptions> g) {
        if (!h) return nullptr;
        using fptr = GDynamicDigitization* (*)(std::shared_ptr<GOptions>);
 
        auto sym = dlsym(h, "GDynamicDigitizationFactory");
        if (!sym) return nullptr;
 
        auto func = reinterpret_cast<fptr>(sym);
        return func(g);
    }

    virtual bool decisionToSkipHit(double energy) {
        if (energy == 0 && !recordZeroEdep) {
            return true;
        }
        return false;
    }

    virtual bool decisionToSkipHit(double energy, [[maybe_unused]] const G4Step* thisStep) {
        return decisionToSkipHit(energy);
    }

    [[nodiscard]] bool shouldStopTrackAfterHit(const G4Step* thisStep) const {
        check_if_log_defined();
        return shouldStopTrackAfterHitImpl(thisStep);
    }

    [[nodiscard]] virtual bool shouldStopTrackAfterHitImpl(
        [[maybe_unused]] const G4Step* thisStep) const {
        return false;
    }

    // TODO: REMOVE THIS EVERYWHERE also remove check_if_log_defined
    void set_loggers(const std::shared_ptr<GOptions> &g) { gopts = g; }

    void setDigitizationVariation(const std::string &v) { digitization_variation = v; }

    [[nodiscard]] std::string getDigitizationVariation() const { return digitization_variation; }

    void setHitRejectionPolicies(const std::string &systemName);

    [[nodiscard]] bool apply_thresholds(GHit* ghit, GDigitizedData* digitizedData) {
        if (!applyThresholds_ && !thresholds_are_intrinsic_impl()) { return false; }
        return apply_thresholds_impl(ghit, digitizedData);
    }

    [[nodiscard]] virtual bool apply_thresholds_impl([[maybe_unused]] GHit* ghit,
                                                     [[maybe_unused]] GDigitizedData* digitizedData) {
        return false;
    }

    [[nodiscard]] virtual bool thresholds_are_intrinsic_impl() const { return false; }

    [[nodiscard]] bool apply_efficiency(GHit* ghit, GDigitizedData* digitizedData) {
        if (!applyInefficiencies_ && !efficiencies_are_intrinsic_impl()) { return false; }
        return apply_efficiency_impl(ghit, digitizedData);
    }

    [[nodiscard]] virtual bool apply_efficiency_impl([[maybe_unused]] GHit* ghit,
                                                     [[maybe_unused]] GDigitizedData* digitizedData) {
        return false;
    }

    [[nodiscard]] virtual bool efficiencies_are_intrinsic_impl() const { return false; }
 
private:
    bool recordZeroEdep = false;

    bool applyThresholds_     = false;
    bool applyInefficiencies_ = false;

    std::string digitization_variation = "default";
 
protected:
    std::shared_ptr<GOptions> gopts;

    void check_if_log_defined() const {
        if (gopts == nullptr) {
            std::cerr << guts::KRED
                    << "Fatal Error: GDynamicDigitization: goption is not set for this plugin or one of the loggers is null."
                    << std::endl;
            std::cerr << "The set_loggers function needs to be called." << std::endl;
            std::cerr << "For example: dynamicRoutines[\"ctof\"]->set_loggers(gopts);" << std::endl;
            std::cerr << guts::RST << std::endl;
            exit(1);
        }
    }
};
 
namespace gdynamicdigitization {
    using dRoutinesMap = std::unordered_map<std::string, std::shared_ptr<GDynamicDigitization> >;

    inline std::shared_ptr<GDynamicDigitization> load_dynamicRoutine(const std::string &plugin_name,
                                                                     const std::shared_ptr<GOptions> &gopts) {
        GManager manager(gopts);
        return manager.LoadAndRegisterObjectFromLibrary<GDynamicDigitization>(plugin_name, gopts);
    }

    inline std::shared_ptr<const dRoutinesMap> dynamicRoutinesMap(const std::vector<std::string> &plugin_names,
                                                                  const std::shared_ptr<GOptions> &gopts) {
        auto log = std::make_shared<GLogger>(gopts, SFUNCTION_NAME, GDIGITIZATION_LOGGER);
        GManager manager(gopts);
 
        auto routines = std::make_shared<dRoutinesMap>();
 
        for (const auto &plugin: plugin_names) {
            routines->emplace(plugin, manager.LoadAndRegisterObjectFromLibrary<GDynamicDigitization>(plugin, gopts));
            log->info(0, "dynamicRoutinesMap[", plugin, "]: ", (*routines)[plugin]);
        }
 
        return routines;
    }
} // namespace gdynamicdigitization