SToGS_G4_CopClusterHit.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_CopClusterHit_h
#define SToGS_CopClusterHit_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 CopClusterHit : public G4VHit
    {
    public:
        CopClusterHit();
        virtual ~CopClusterHit();
        CopClusterHit(const CopClusterHit &right);
        
        const CopClusterHit& operator=(const CopClusterHit &right);
        G4int operator==(const CopClusterHit &right) const;
        
        inline void *operator new(size_t);
        inline void operator delete(void *aHit);
        
    public:
// setters
        void SetDetID  (G4int id)
        {
            detID = id;
        }
        void SetMotherID(G4int id)
        {
            motherID = id;
        }
        void SetEdep(G4double de = 0.0)
        {
            edep = de;
        }
        void SetToF (G4double de, G4double tf = 0.0)
        {
            ToF = de*tf;
        }
        void SetPos(G4double de, G4ThreeVector xyz = G4ThreeVector(0.,0.,0.))
        {
            pos = de*xyz;
        }
        void SetDetName(G4String name)
        {
            detName = name;
        }
        void SetMotherDetName(G4String name)
        {
            motherDetName = name;
        }
        void SetNbHits(G4int nb = 0)
                {
            NbHits = nb;
        }
// getters
        G4int GetDetID() const
                {
            return detID;
        }
        G4int GetMotherID() const
                {
            return motherID;
        }
        G4double GetEdep() const
                {
            return edep;
        }
        G4double GetToF()  const
                {
            return ToF;
        }
        const G4ThreeVector &GetPos()
        {
            return pos;
        }
        G4int GetNbHits() const
                {
            return NbHits;
        }
// others
        void AddOneHit()
                {
            NbHits++;
        }
        void AddEdep(G4double de)
                {
            edep += de;
        }
        void AddToF (G4double de, G4double t)
                {
            ToF += de*t;
        }
        void AddPos (G4double de, G4ThreeVector xyz)
                {
            pos.setX(pos.x()+de*xyz.x()); pos.setY(pos.y()+de*xyz.y()); pos.setZ(pos.z()+de*xyz.z());
        }
        void EndOfEvent();
        
        void Draw();
        void Print();
        
    private:
        G4int detID;
        G4int motherID;
        
        G4double edep;
        G4double ToF;
        
        G4ThreeVector pos;
        
        G4String detName;
        G4String motherDetName;
        
        G4int NbHits;
    };

    typedef G4THitsCollection<CopClusterHit> CopClusterHitsCollection;
    extern G4ThreadLocal G4Allocator<CopClusterHit> *CopClusterHitAllocator;
    
    inline void* CopClusterHit::operator new(size_t)
    {
        if( !CopClusterHitAllocator )
            CopClusterHitAllocator = new G4Allocator<CopClusterHit>;
        return CopClusterHitAllocator->MallocSingle();
    }
    inline void CopClusterHit::operator delete(void *aHit)
    {
        CopClusterHitAllocator->FreeSingle((CopClusterHit*) aHit);
    }
} // SToGS Namespace

#endif