SToGS_G4_TrackerHit.hh

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//

#ifndef SToGS_TrackerHit_h
#define SToGS_TrackerHit_h 1

#include "G4VHit.hh"
#include "G4THitsCollection.hh"
#include "G4Allocator.hh"
#include "G4ThreeVector.hh"
#include "G4Types.hh"

#ifndef G4MULTITHREADED
#define G4ThreadLocal
#endif

namespace SToGS {

    class TrackerHit : public G4VHit
    {
    public:
        TrackerHit();
        virtual ~TrackerHit();
        TrackerHit(const TrackerHit &right);
        
        const TrackerHit& operator=(const TrackerHit &right);
        G4int operator==(const TrackerHit &right) const;
        
        inline void *operator new(size_t);
        inline void operator delete(void *aHit);
        
    public:
// setters
        void SetTrackID(G4int id)
        {
            trackID = id;
        }
        void SetParentID(G4int id)
        {
            parentID = id;
        }
        void SetPrimaryID(G4int id)
        {
            primaryID = id;
        }
        
        void SetDetID  (G4int id)
        {
            detID = id;
        }
        void SetMotherID(G4int id)
        {
            motherID = id;
        }
        void SetEdep(G4double de)
        {
            edep = de;
        }
        void SetToF (G4double tf)
        {
            ToF = tf;
        }
        void SetPos(G4ThreeVector xyz)
        {
            pos = xyz;
        }
        void SetProcessName(G4String name)
        {
            processName = name;
        }
        void SetParticleName(G4String name)
        {
            particleName = name;
        }
        void SetDetName(G4String name)
        {
            detName = name;
        }
        void SetMotherDetName(G4String name)
        {
            motherDetName = name;
        }
        void SetPDGcode(G4int code)
        {
            PDGcode = code;
        }
 // getters
        G4int GetTrackID()
        {
            return trackID;
        }
        G4int GetParentID()
        {
            return parentID;
        }
        G4int GetPrimaryID()
        {
            return primaryID;
        }
        G4int GetDetID()
        {
            return detID;
        }
        G4int GetMotherID()
        {
            return motherID;
        }
        G4double GetEdep()
        {
            return edep;
        }
        G4double GetToF()
        {
            return ToF;
        }
        G4int  GetPDGcode()
        {
            return PDGcode;
        }
        G4ThreeVector &GetPos()
        {
            return pos;
        }
        G4String &GetProcessName()
        {
            return processName;
        }
        G4String &GetParticleName()
        {
            return particleName;
        }
        G4String &GetDetName()
        {
            return detName;
        }
        G4String &GetMotherDetName()
        {
            return motherDetName;
        }
        
// others
        void Draw();
        void Print();
        
    private:
        G4int trackID;  // current track ID to which this hit belongs
        G4int parentID; //  parent track ID to which this hit belongs
        G4int primaryID;        // primary track ID to which this hit belongs
        
        G4int detID;
        G4int motherID;
        
        G4double edep;
        G4double ToF;
        
        G4ThreeVector pos;
        
        G4String processName;
        G4String particleName;
        G4String detName;
        G4String motherDetName;
        
        
        G4int PDGcode;  // PDGcode of particle which hit the detector
    };
    
    typedef G4THitsCollection<TrackerHit> TrackerHitsCollection;
    extern G4ThreadLocal G4Allocator<TrackerHit> *TrackerHitAllocator;
    
    inline void* TrackerHit::operator new(size_t)
    {
        if( !TrackerHitAllocator )
            TrackerHitAllocator = new G4Allocator<TrackerHit>;
        return TrackerHitAllocator->MallocSingle();
    }
    
    inline void TrackerHit::operator delete(void *aHit)
    {
        TrackerHitAllocator->FreeSingle((TrackerHit*) aHit);
    }
} // SToGS Namespace

#endif