G4UMDPixelHit.h

Go to the documentation of this file.

#ifndef _G4StationSimulatorOG_G4UMDPixelHit_h_
#define _G4StationSimulatorOG_G4UMDPixelHit_h_

#include <G4VHit.hh>
#include <G4THitsCollection.hh>
#include <G4Allocator.hh>
#include <G4ThreeVector.hh>
#include <G4VPhysicalVolume.hh>


namespace G4StationSimulatorOG {

  class G4UMDPixelHit : public G4VHit {

  public:
    G4UMDPixelHit() = default;
    virtual ~G4UMDPixelHit() = default;

    inline void* operator new(const size_t size);
    inline void operator delete(void* const hit);

    // This methods should be implemented to draw and print with customized style
    void Draw() override;
    void Print() override { }

    // Setter methods
    void AddHit(const G4double t) { fTimes.push_back(t); }
    void SetModuleId(const G4int id) { fModuleId = id; }
    void SetPixelId(const G4int id) { fPixelId  = id; }
    void SetPixelName(const G4String name) { fPixelName = name; }
    void SetDrawIt(const G4bool draw) { fDrawIt = draw; }
    void SetUMDPixelPhysVol(G4VPhysicalVolume* const physVol) { fHitPhysVol = physVol; }

    // Getters methods
    const std::vector<G4double>& GetTimes() const { return fTimes; }
    const G4String& GetPixelName() const { return fPixelName; }
    G4int GetPixelId() const { return fPixelId; }
    G4int GetModuleId() const { return fModuleId; }
    G4bool GetDrawIt() const { return fDrawIt; }
    G4VPhysicalVolume* GetUMDPixelPhysVol() const { return fHitPhysVol; }

  private:
    std::vector<G4double> fTimes;
    G4int fModuleId = 0;
    G4int fPixelId = 0;
    G4String fPixelName = "unnamed";
    G4bool fDrawIt = false;
    G4VPhysicalVolume* fHitPhysVol = nullptr;

  };


  using G4UMDPixelHitCollection = G4THitsCollection<G4StationSimulatorOG::G4UMDPixelHit>;


  // Class for fast allocation of objects to the heap
  extern G4ThreadLocal G4Allocator<G4StationSimulatorOG::G4UMDPixelHit>* gG4UMDPixelHitAllocator;


  // Operators new and delete must be provided
  inline
  void*
  G4UMDPixelHit::operator new(size_t /*size*/)
  {
    if (!gG4UMDPixelHitAllocator)
      gG4UMDPixelHitAllocator = new G4Allocator<G4UMDPixelHit>;

    return gG4UMDPixelHitAllocator->MallocSingle();
  }


  inline
  void
  G4UMDPixelHit::operator delete(void* const hit)
  {
    gG4UMDPixelHitAllocator->FreeSingle((G4UMDPixelHit*)hit);
  }

}


#endif