TrackSummary.hh

Go to the documentation of this file.

#ifndef SLIC_TRACKSUMMARY_HH_
#define SLIC_TRACKSUMMARY_HH_ 1
 
// LCIO
#include "lcio.h"
#include "IMPL/MCParticleImpl.h"
 
// Geant4
#include "globals.hh"
#include "G4ThreeVector.hh"
#include "G4Allocator.hh"
 
// STL
#include <vector>
#include <bitset>
 
using IMPL::MCParticleImpl;
 
class G4Track;
 
namespace slic {
 
class TrackSummary;
class TrackManager;
 
typedef std::vector<TrackSummary*> TrackSummaryVector;
typedef std::map<G4int, TrackSummary*> TrackSummaryMap;
 
class TrackSummary {
 
    public:
 
        TrackSummary(const G4Track* track, G4bool toBeSaved, G4bool backScattering = false);
 
        virtual ~TrackSummary() {
        }
 
        inline void *operator new(size_t);
 
        inline void operator delete(void *);
 
        void update(const G4Track* track);
 
        G4double getCharge() const {
            return _charge;
        }
 
        G4ThreeVector getEndPoint() const {
            return _endPoint;
        }
 
        G4double getEnergy() const {
            return sqrt(_momentum[0] * _momentum[0] + _momentum[1] * _momentum[1] + _momentum[2] * _momentum[2] + _mass * _mass);
        }
 
        G4double getMass() const {
            return _mass;
        }
 
        G4int getHepEvtStatus() const {
            return _hepEvtStatus;
        }
 
        G4int getSimulatorStatus() const {
            return _simstatus.to_ulong();
        }
 
        G4ThreeVector getMomentum() const {
            return _momentum;
        }
 
        TrackSummary* getParent() const {
            return _parent;
        }
 
        G4int getPDG() const {
            return _PDG;
        }
 
        const G4ThreeVector& getVertex() const {
            return _vertex;
        }
 
        G4int getTrackID() const {
            return _trackID;
        }
 
        G4int getParentID() const {
            return _parentTrackID;
        }
 
        G4double getTrackLength() const {
            return _trackLength;
        }
 
        G4bool getToBeSaved() const {
            return _toBeSaved;
        }
 
        void setToBeSaved() {
            _toBeSaved = true;
        }
 
        G4bool getBackScattering() const {
            return _backScattering;
        }
 
        void setBackScattering() {
            _backScattering = true;
        }
 
        void setParentToBeSaved();
 
        MCParticleImpl* getMCParticle() {
            return _mcparticle;
        }
 
        void setMCParticle(MCParticleImpl* mcp) {
            _mcparticle = mcp;
        }
 
        void setHasTrackerHit() {
            _hasTrackerHit = true;
        }
 
        void buildMCParticle();
 
        TrackSummary* findParent() const;
 
    private:
 
// Member data
 
        G4double _charge;
        G4ThreeVector _endPoint;
        G4double _energy;
        G4double _mass;
        G4int _hepEvtStatus;
        std::bitset<32> _simstatus;
        G4ThreeVector _momentum;
        G4ThreeVector _momentumAtEndpoint;
        TrackSummary* _parent;
        G4int _PDG;
        G4ThreeVector _vertex;
        G4double _globalTime;
 
        G4bool _toBeSaved;
 
        G4bool _backScattering;
        G4int _trackID;
        G4int _parentTrackID;
        G4double _trackLength;
 
        MCParticleImpl* _mcparticle;
        G4bool _mcParticleIsUpToDate;
 
        G4bool _hasTrackerHit;
 
        static TrackManager* m_trackManager;
};
 
extern G4Allocator<TrackSummary> TrackSummaryAllocator;
 
inline void* TrackSummary::operator new(size_t) {
    void *aTrackSummary;
    aTrackSummary = (void*) TrackSummaryAllocator.MallocSingle();
    return aTrackSummary;
}
 
inline void TrackSummary::operator delete(void* aTrackSummary) {
    TrackSummaryAllocator.FreeSingle((TrackSummary*) aTrackSummary);
}
 
}
 
#endif