ghit.h

Go to the documentation of this file.

#pragma once
 
// HitBitSet definition
#include "ghitConventions.h"
 
// geant4
#include "G4VHit.hh"
#include "G4THitsCollection.hh"
#include "G4Allocator.hh"
 
#include "G4ThreeVector.hh"
#include "G4Step.hh"
#include "G4Colour.hh"
 
// gemc
#include "gtouchable.h"
 
// c++
#include <optional>
#include <atomic>
 
class GHit : public G4VHit
{
public:
    GHit(std::shared_ptr<GTouchable> gt, HitBitSet hbs, const G4Step* thisStep = nullptr,
         const std::string&          cScheme                                   = "default");
 
    ~GHit() override = default;
 
    inline void* operator new(size_t);
 
    inline void operator delete(void*);
 
    void Draw() override;
 
    [[nodiscard]] bool is_same_hit(const GHit* hit) const;
 
private:
    G4Colour colour_touch, colour_hit, colour_passby;
 
    bool setColorSchema();
 
    std::string colorSchema;
 
    std::shared_ptr<GTouchable> gtouchable;
 
    // -------------------------------------------------------------------------
    // Per-step data (vectors)
    // -------------------------------------------------------------------------
 
    std::vector<double> edeps;
 
    std::vector<double> times;
 
    std::vector<G4ThreeVector> globalPositions;
 
    std::vector<G4ThreeVector> localPositions;
 
    // Optional per-step data, controlled by HitBitSet (see ghitConventions.h : meaning of each bit)
 
    std::vector<int> pids;
 
    std::vector<int> tids;
 
    std::vector<double> Es;
 
    std::vector<std::string> processNames;
 
    std::vector<double> stepSize;
 
    // -------------------------------------------------------------------------
    // Aggregated / calculated quantities (lazy)
    // -------------------------------------------------------------------------
 
    std::optional<double> totalEnergyDeposited;
 
 
    double averageTime;
 
    G4ThreeVector avgGlobalPosition;
 
    G4ThreeVector avgLocalPosition;
 
    std::string processName;
 
    bool addHitInfosForBitIndex(size_t bitIndex, bool test, const G4Step* thisStep);
 
    static std::atomic<int> globalHitCounter;
 
public:
    // -------------------------------------------------------------------------
    // Inline accessors (returning copies by design)
    // -------------------------------------------------------------------------
 
    [[nodiscard]] inline std::vector<double> getEdeps() const { return edeps; }
 
    [[nodiscard]] inline std::vector<double> getTimes() const { return times; }
 
    [[nodiscard]] inline std::vector<G4ThreeVector> getGlobalPositions() const { return globalPositions; }
 
    [[nodiscard]] inline std::vector<G4ThreeVector> getLocalPositions() const { return localPositions; }
 
    [[nodiscard]] inline std::vector<int> getPids() const { return pids; }
 
    [[nodiscard]] inline int getPid() const { return pids.front(); }
 
    [[nodiscard]] inline  std::vector<int> getTids() const { return tids; }
 
    [[nodiscard]] inline int getTid() const { return tids.front(); }
 
    [[nodiscard]] inline std::vector<double> getEs() const { return Es; }
 
    [[nodiscard]] inline double getE() const { return Es.front(); }
 
    [[nodiscard]] inline size_t nsteps() const { return Es.size(); }
 
    [[nodiscard]] inline std::string getProcessName() const { return processName; }
 
    [[nodiscard]] inline std::shared_ptr<GTouchable> getGTouchable() const { return gtouchable; }
 
    [[nodiscard]] inline std::vector<GIdentifier> getGID() const { return gtouchable->getIdentity(); }
 
    [[nodiscard]] inline std::vector<double> getDetectorDimensions() const {
        return gtouchable->getDetectorDimensions();
    }
 
    [[nodiscard]] inline double getMass() const { return gtouchable->getMass(); }
 
    // -------------------------------------------------------------------------
    // Aggregation / calculation API
    // -------------------------------------------------------------------------
 
    void calculateInfosForBit(int bit);
 
    double getTotalEnergyDeposited();
 
    double getAverageTime();
 
    G4ThreeVector getAvgLocalPosition();
 
    G4ThreeVector getAvgGlobaPosition();
 
    // -------------------------------------------------------------------------
    // Hit filling / testing helpers
    // -------------------------------------------------------------------------
 
    void addHitInfosForBitset(HitBitSet hbs, const G4Step* thisStep);
 
    void randomizeHitForTesting(int nsteps);
 
    [[nodiscard]] std::vector<int> getTTID() const;
 
    static GHit* create(const std::shared_ptr<GOptions>& gopts) {
        HitBitSet hitBitSet;
        auto      gt  = GTouchable::create(gopts);
        auto      hit = new GHit(gt, hitBitSet);
        // Randomize between 1 and 10 steps in a deterministic, thread-safe manner.
        hit->randomizeHitForTesting(1 + globalHitCounter.fetch_add(1, std::memory_order_relaxed) % 10);
        return hit;
    }
};
 
// MT definitions, as from:
// https://twiki.cern.ch/twiki/bin/view/Geant4/QuickMigrationGuideForGeant4V10
extern G4ThreadLocal G4Allocator<GHit>* GHitAllocator;
using GHitsCollection = G4THitsCollection<GHit>;
 
inline void* GHit::operator new(size_t) {
    if (!GHitAllocator) GHitAllocator = new G4Allocator<GHit>;
    return (void*)GHitAllocator->MallocSingle();
}
 
inline void GHit::operator delete(void* hit) {
    if (!GHitAllocator) { GHitAllocator = new G4Allocator<GHit>; }
 
    GHitAllocator->FreeSingle((GHit*)hit);
}
 
[[nodiscard]] inline std::string getIdentityString(std::vector<GIdentifier> gidentity) {
    // Build a compact label from the stored identifier vector.
    std::string identifierString;
    for (size_t i = 0; i < gidentity.size() - 1; i++) {
        identifierString += gidentity[i].getName() + "->" + std::to_string(gidentity[i].getValue()) + ", ";
    }
    identifierString += gidentity.back().getName() + "->" + std::to_string(gidentity.back().getValue());
    return identifierString;
}
 
[[nodiscard]] inline std::map<std::string, int> getIdentityMap(std::vector<GIdentifier> gidentity) {
    std::map<std::string, int> identityMap;
    for (auto& id : gidentity) {
        identityMap[id.getName()] = id.getValue();
    }
    return identityMap;
}