TrackInformation.h

Go to the documentation of this file.

#ifndef SimG4Core_TrackInformation_H
#define SimG4Core_TrackInformation_H 

#include "G4VUserTrackInformation.hh"

#include "G4Allocator.hh"

class TrackInformation : public G4VUserTrackInformation {

public:
  ~TrackInformation() override {}
  inline void * operator new(size_t);
  inline void   operator delete(void * TrackInformation);

  bool storeTrack() const   { return storeTrack_; }
  void storeTrack(bool v)    
  { if (v) storeTrack_ = v; if (v == true) putInHistory(); }

  bool isPrimary() const    { return isPrimary_; }
  void isPrimary(bool v)    { isPrimary_ = v; }

  bool hasHits() const  { return hasHits_; }
  void hasHits(bool v)  { hasHits_ = v; }

  bool isGeneratedSecondary() const { return isGeneratedSecondary_; }
  void isGeneratedSecondary(bool v) { isGeneratedSecondary_ = v; }

  bool isInHistory() const { return isInHistory_; }
  void putInHistory()      { isInHistory_= true; }

  bool isAncestor() const { return flagAncestor_; }
  void setAncestor()      { flagAncestor_ = true; }

  // Calo section
  int getIDonCaloSurface() const       { return idOnCaloSurface_; }
  void setIDonCaloSurface(int id, int ical, int last, int pdgID, double p) {
    idOnCaloSurface_ = id; idCaloVolume_ = ical; idLastVolume_ = last; 
    caloSurfaceParticlePID_ = pdgID; caloSurfaceParticleP_= p;}
  int    getIDCaloVolume() const           { return idCaloVolume_; }
  int    getIDLastVolume() const           { return idLastVolume_; }
  bool   caloIDChecked() const             { return caloIDChecked_; }
  void   setCaloIDChecked(bool f)          { caloIDChecked_ = f; }
  int    caloSurfaceParticlePID() const    { return caloSurfaceParticlePID_; }
  void   setCaloSurfaceParticlePID(int id) { caloSurfaceParticlePID_ = id; }
  double caloSurfaceParticleP() const      { return caloSurfaceParticleP_; }
  void   setCaloSurfaceParticleP(double p) { caloSurfaceParticleP_ = p; }

  // Generator information
  int    genParticlePID() const            { return genParticlePID_; }
  void   setGenParticlePID(int id)         { genParticlePID_ = id; }
  double genParticleP() const              { return genParticleP_; }
  void   setGenParticleP(double p)         { genParticleP_ = p; }

  // remember the PID of particle entering the CASTOR detector. This is needed
  // in order to scale the hadronic response
  bool hasCastorHit() const { return hasCastorHit_; }
  void setCastorHitPID(const int pid) { hasCastorHit_=true; castorHitPID_ = pid; }
  int getCastorHitPID() const { return castorHitPID_; }

  void Print() const override;
private:
  bool   storeTrack_;    
  bool   isPrimary_;
  bool   hasHits_;
  bool   isGeneratedSecondary_;
  bool   isInHistory_;
  bool   flagAncestor_;
  int    idOnCaloSurface_;
  int    idCaloVolume_;
  int    idLastVolume_;
  bool   caloIDChecked_;
  int    genParticlePID_, caloSurfaceParticlePID_;
  double genParticleP_, caloSurfaceParticleP_;

  bool hasCastorHit_;
  int castorHitPID_;

  // Restrict construction to friends
  TrackInformation() :G4VUserTrackInformation(),storeTrack_(false),isPrimary_(false),
    hasHits_(false),isGeneratedSecondary_(false),isInHistory_(false),
    flagAncestor_(false),idOnCaloSurface_(0),idCaloVolume_(-1),
    idLastVolume_(-1),caloIDChecked_(false), genParticlePID_(-1),
    caloSurfaceParticlePID_(0), genParticleP_(0), caloSurfaceParticleP_(0),
    hasCastorHit_(false), castorHitPID_(0) {}
    friend class NewTrackAction;
};

extern G4ThreadLocal G4Allocator<TrackInformation> *fpTrackInformationAllocator;

inline void * TrackInformation::operator new(size_t)
{
  if (!fpTrackInformationAllocator) fpTrackInformationAllocator = 
    new G4Allocator<TrackInformation>;
  return (void*)fpTrackInformationAllocator->MallocSingle();
}

inline void TrackInformation::operator delete(void * trkInfo)
{  
  fpTrackInformationAllocator->FreeSingle((TrackInformation*) trkInfo); 
}

#endif