simulations/wavepid/include/OMSimHitManager.hh

Go to the documentation of this file.

 
#pragma once
 
#include "OMSimPMTResponse.hh"
#include "ROOTHitManager.hh"
 
#include <G4ThreeVector.hh>
#include <fstream>
#include <G4AutoLock.hh>
#include <G4Threading.hh>
#include <map>
#include <vector>
 
struct HitStats
{
    std::vector<G4long> eventId;                         
    std::vector<G4double> hitTime;                       
    std::vector<G4double> entryTime;                     
    std::vector<G4double> flightTime;                    
    std::vector<G4double> pathLenght;                    
    std::vector<G4double> energy;                        
    std::vector<G4int> PMTnr;                            
    std::vector<G4ThreeVector> direction;                
    std::vector<G4ThreeVector> localPosition;            
    std::vector<G4ThreeVector> globalPosition;           
    std::vector<G4double> generationDetectionDistance;   
    std::vector<OMSimPMTResponse::PMTPulse> PMTresponse; 
    std::vector<G4String> photonOrigin;                  
    std::vector<G4int> parentID;                         
    std::vector<G4String> parentType;                    
    std::vector<G4String> parentProcess;                 
};
 
class OMSimHitManager
{
    OMSimHitManager();
    ~OMSimHitManager() = default;
    OMSimHitManager(const OMSimHitManager&) = delete;
    OMSimHitManager& operator=(const OMSimHitManager&) = delete;
 
public:
    static void init();
 
    static void setROOTOutputFile(const std::string& filename);
 
    static void shutdown();
 
    static OMSimHitManager& getInstance();
 
    void appendHitInfo(
        G4int p_eventid,
        G4double p_globalTime,
        G4double p_entryTime,
        G4double p_localTime,
        G4double p_trackLength,
        G4double p_energy,
        G4int pPMTHitNumber,
        G4ThreeVector pMomentumDirection,
        G4ThreeVector pGlobalPos,
        G4ThreeVector pLocalPos,
        G4double p_distance,
        OMSimPMTResponse::PMTPulse pResponse,
        G4String pPhotonOrigin,
        G4int pParentID,
        std::string pParentType,
        G4String pParentProcess,
        G4double p_wavelength,
        G4int pModuleIndex);
 
    void reset();
    std::vector<double> countMergedHits(int pModuleIndex = 0, bool pDEweight = false);
    void setNumberOfPMTs(int pNumberOfPMTs, int pModuleIndex = 0);
    HitStats getMergedHitsOfModule(int pModuleIndex = 0);
    HitStats getSingleThreadHitsOfModule(int pModuleIndex = 0);
    bool areThereHitsInModuleSingleThread(int pModuleIndex = 0);
    void sortHitStatsByTime(HitStats& pHits);
    std::vector<int> calculateMultiplicity(const G4double pTimeWindow, int pModuleNumber = 0);
    G4int getNextDetectorIndex() { return ++m_currentIndex; }
    G4int getNumberOfModules() { return m_currentIndex + 1; }
 
    void mergeThreadData();
 
    std::map<G4int, HitStats> m_moduleHits;
 
private:
    std::map<G4int, G4int> m_numberOfPMTs;
    G4int m_currentIndex;
    static G4Mutex m_mutex;
    static OMSimHitManager* m_instance;
 
    struct ThreadLocalData {
        std::map<G4int, HitStats> moduleHits;
    };
    G4ThreadLocal static ThreadLocalData* m_threadData;
 
    ROOTHitManager* m_rootManager = nullptr;
};
 
inline OMSimHitManager* g_hitManager = nullptr;