gdynamicdigitization.h

Go to the documentation of this file.

#pragma once
 
#include "greadoutSpecs.h"
#include "gfactory_options.h"
 
// gemc
#include "gfactory.h"
#include "gtouchable.h"
#include "ghit.h"
#include "gDigitizedData.h"
#include "gTrueInfoData.h"
#include "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) {
    }
 
    virtual ~GDynamicDigitization() = default;
 
    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; }
 
    [[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;
    }
 
    // TODO: REMOVE THIS EVERYWHERE also remove check_if_log_defined
    void set_loggers(const std::shared_ptr<GOptions>& g) { gopts = g; }
 
private:
    bool recordZeroEdep = false;
 
protected:
    std::shared_ptr<GOptions> gopts;
 
    void check_if_log_defined() const {
        if (gopts == nullptr) {
            std::cerr << 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 << 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