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];
    }
};
 
class GDynamicDigitization : public GBase<GDynamicDigitization>
{
public:
    explicit GDynamicDigitization(const std::shared_ptr<GOptions>& g) : GBase(g, GDIGITIZATION_LOGGER) {
    }
 
    virtual ~GDynamicDigitization() = default;
 
    [[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::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