gtouchable.h

Go to the documentation of this file.

#pragma once
 
// gemc
#include <gemc/gbase/gbase.h>
 
// c++
#include <vector>
#include <string>
#include <memory>
#include <optional>
 
// gtouchable
#include <CLHEP/Units/SystemOfUnits.h>
 
#include "gtouchable_options.h"
#include "gtouchableConventions.h"
 

enum GTouchableType
{
    readout,
    flux,
    gPhotonDetector,
    particle_counter,
    dosimeter,
    integral_counter
};
 
// ------------------------------------------------------------------------
// Convert enum to string for logging / debugging.
// ------------------------------------------------------------------------
namespace gtouchable {
    inline const char* to_string(GTouchableType t) {
        switch (t) {
            case GTouchableType::readout: return "readout";
            case GTouchableType::flux: return gtouchable::FLUXNAME;
            case GTouchableType::gPhotonDetector: return gtouchable::GPHOTON_DETECTORNAME;
            case GTouchableType::particle_counter: return gtouchable::COUNTERNAME;
            case GTouchableType::dosimeter: return gtouchable::DOSIMETERNAME;
            case GTouchableType::integral_counter: return gtouchable::INTEGRAL_COUNTERNAME;
            default: return "unknown-gtouchable";
        }
    }
}

struct GIdentifier
{
public:
    GIdentifier(const std::string& n, int v) : idName{n}, idValue{v} {
    }

    bool operator==(const GIdentifier& gid) const { return this->idValue == gid.idValue; }

    [[nodiscard]] inline std::string getName() const { return idName; }

    [[nodiscard]] inline int getValue() const { return idValue; }

    inline void setValue(int v) { idValue = v; }
 
private:
    std::string idName;  
    int         idValue; 

    friend std::ostream& operator<<(std::ostream& stream, const GIdentifier& gidentifier);
};
 

class GTouchable : public GBase<GTouchable>
{
public:
    GTouchable(const GTouchable&)            = default;
    GTouchable& operator=(const GTouchable&) = default;

    GTouchable(const std::shared_ptr<GOptions>& gopt,
               const std::string&               digitization,
               const std::string&               gidentityString,
               const std::vector<double>&       dimensions,
               const double&                    mass);

    GTouchable(const std::shared_ptr<GLogger>& logger,
               const std::string&              digitization,
               const std::string&              gidentityString,
               const std::vector<double>&      dimensions,
               const double&                   mass);

    GTouchable(const std::shared_ptr<GTouchable>& base, int newTimeIndex)
        : GBase<GTouchable>(*base),
          gType(base->gType),
          gidentity(base->gidentity),
          trackId(base->trackId),
          eMultiplier(base->eMultiplier),
          stepTimeAtElectronicsIndex(newTimeIndex) {
        log->debug(CONSTRUCTOR, "Copy-with-time-index", gtouchable::to_string(gType), " ", getIdentityString());
    }

    ~GTouchable() { log->debug(DESTRUCTOR, gtouchable::to_string(gType), " ", getIdentityString()); }

    bool operator==(const GTouchable& gtouchable) const;

    [[nodiscard]] std::string cellKey() const;

    inline void assignTrackId(int tid) { trackId = tid; }

    inline void assignPId(int p) { pid = p; }

    [[nodiscard]] inline double getEnergyMultiplier() const { return eMultiplier; }

    inline void assignStepTimeAtElectronicsIndex(int timeIndex) { stepTimeAtElectronicsIndex = timeIndex; }

    [[nodiscard]] inline const std::optional<int>& getStepTimeAtElectronicsIndex() const {
        return stepTimeAtElectronicsIndex;
    }

    [[nodiscard]] inline std::vector<GIdentifier> getIdentity() const { return gidentity; }

    inline void setIdentityValue(size_t index, int value) { gidentity.at(index).setValue(value); }

    [[nodiscard]] inline std::string getIdentityString() const {
        std::string idString;
        for (const auto& id : gidentity) { idString += id.getName() + ": " + std::to_string(id.getValue()) + " "; }
        return idString;
    }

    [[nodiscard]] inline std::vector<double> getDetectorDimensions() const { return detectorDimensions; }

    [[nodiscard]] inline double getMass() const { return mass; }

    [[nodiscard]] bool exists_in_vector(const std::vector<GTouchable>& v) const {
        for (const auto& gt : v) {
            if (*this == gt) {
                log->info(2, "GTouchable", this, " exists in vector.");
                return true;
            }
        }
        log->info(2, "GTouchable", this, " does not exist in vector.");
 
        return false;
    }

    static std::shared_ptr<GTouchable> create(const std::shared_ptr<GOptions>& gopt) {
        int           touchableNumber = globalGTouchableCounter.fetch_add(1, std::memory_order_relaxed);
        int           sector          = ( touchableNumber % 6 ) + 1;
        int           paddle          = ( touchableNumber % 20 ) + 1;
        std::string   identity        = "sector: " + std::to_string(sector) + ", paddle: " + std::to_string(paddle);
        const auto&   dimensions      = {10.0, 20.0, 30.0};
        const double& mass            = 100 * CLHEP::g;
 
        return std::make_shared<GTouchable>(gopt, "readout", identity, dimensions, mass);
    }

    static std::shared_ptr<GTouchable> create(const std::shared_ptr<GLogger>& logger) {
        int           touchableNumber = globalGTouchableCounter.fetch_add(1, std::memory_order_relaxed);
        int           sector          = ( touchableNumber % 6 ) + 1;
        int           paddle          = ( touchableNumber % 20 ) + 1;
        std::string   identity        = "sector: " + std::to_string(sector) + ", paddle: " + std::to_string(paddle);
        const auto&   dimensions      = {10.0, 20.0, 30.0};
        const double& mass            = 100 * CLHEP::g;
 
        return std::make_shared<GTouchable>(logger, "readout", identity, dimensions, mass);
    }
 
private:
    GTouchableType gType; 
    std::vector<GIdentifier> gidentity;     
    int trackId;                            
    int pid;                                
    double eMultiplier;                     
    std::optional<int> stepTimeAtElectronicsIndex; 
    std::vector<double> detectorDimensions; 
    double mass;

    friend std::ostream& operator<<(std::ostream& stream, const GTouchable& gtouchable);

    inline static std::atomic<int> globalGTouchableCounter{0};
};