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:
    // Only one of these maps can be filled with values:
    // the size of the map is used by processGTouchableModifiers.
 
    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 handle) {
    //  if (handle == nullptr) return nullptr;
    //  // Must match the extern "C" declaration in the derived factories.
    //  void* maker = dlsym(handle, "GDynamicDigitizationFactory");
    //  if (maker == nullptr) return nullptr;
    //  typedef GDynamicDigitization*(*fptr)();
    //  // Use reinterpret_cast as required.
    //  fptr func = reinterpret_cast<fptr>(reinterpret_cast<void*>(maker));
    //  return func();
    // }
 
    static GDynamicDigitization* instantiate(const dlhandle h, std::shared_ptr<GOptions> g) {
        if (!h) return nullptr;
        using fptr = GDynamicDigitization* (*)(std::shared_ptr<GOptions>);
 
        // Must match the extern "C" declaration in the derived factories.
        auto sym = dlsym(h, "GDynamicDigitizationFactory");
        if (!sym) return nullptr;
 
        auto func = reinterpret_cast<fptr>(sym);
        return func(g);
    }
 
 
    // decides if the hit should be processed or not
    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);
}
 
//  the returned map is shared and immutable
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; // shared_ptr<const ...> prevents mutation
}
 
 
} // namespace gdynamicdigitization