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;
 
    // GTouchable saved here, so it can be used in the overloaded == function
    std::shared_ptr<GTouchable> gtouchable;
 
    // hit data, selected by HitBitSet, to be collected for each step
    // always present:
    std::vector<double>        edeps, times;
    std::vector<G4ThreeVector> globalPositions;
    std::vector<G4ThreeVector> localPositions;
 
    // bit 1
    std::vector<int>         pids;
    std::vector<double>      Es;
    std::vector<std::string> processNames;
 
    // bit 2
    std::vector<double> stepSize;
 
    // calculated/single quantities
    std::optional<double> totalEnergyDeposited;
    double                averageTime;
    G4ThreeVector         avgGlobalPosition;
    G4ThreeVector         avgLocalPosition;
    std::string           processName;
 
    // build hit information based on the bit index and the touchable
    bool addHitInfosForBitIndex(size_t bitIndex, bool test, const G4Step* thisStep);
 
    static std::atomic<int> globalHitCounter;
 
public:
    // inline getters for hit information:
    [[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<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(); }
 
    // calculated quantities
    void calculateInfosForBit(int bit);
 
    double getTotalEnergyDeposited();
 
    double getAverageTime();
 
    G4ThreeVector getAvgLocalPosition();
 
    G4ThreeVector getAvgGlobaPosition();
 
    // gemc api
    // build hit information based on the G4Step
    void addHitInfosForBitset(HitBitSet hbs, const G4Step* thisStep);
 
    void randomizeHitForTesting(int nsteps);
 
 
    [[nodiscard]] std::vector<int> getTTID() const;
 
 
    // create fake GHit for testing purposes, using sector and fake dimensions
    static GHit* create(const std::shared_ptr<GOptions>& gopts) {
        HitBitSet hitBitSet;
        auto      gt  = GTouchable::create(gopts);
        auto      hit = new GHit(gt, hitBitSet);
        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);
}