MHit.h

Go to the documentation of this file.

#ifndef MHit_H
#define MHit_H 1

// %%%%%%%%%%
// G4 headers
// %%%%%%%%%%
#include "G4ThreeVector.hh"
#include "G4VHit.hh"

// %%%%%%%%%%%%%
// gemc headers
// %%%%%%%%%%%%%
#include "detector.h"

// %%%%%%%%%%%
// C++ headers
// %%%%%%%%%%%
#include <iostream>
using namespace std;

// %%%%%%%%%%%%%%%%
// Class definition
// %%%%%%%%%%%%%%%%
class MHit : public G4VHit
{
    
    public:
        MHit();
        virtual ~MHit();
        const MHit& operator=(const MHit&){return *this;}
        
        void Draw();
        
    private:
        // all these infos are recorded 
        // in each step of the hit
        vector<G4ThreeVector>   pos;    
        vector<G4ThreeVector>  Lpos;    
        vector<G4ThreeVector>  vert;    
        vector<double>         edep;    
        vector<double>           dx;    
        vector<double>         time;    
        vector<G4ThreeVector>   mom;    
        vector<double>            E;    
        vector<int>               q;    
        vector<int>             PID;    
        vector<int>            mPID;    
        vector<int>         trackID;    
        vector<int>        mtrackID;    
        vector<G4ThreeVector> mvert;    
        
        vector<detector>  Detectors;    
        
        vector<identifier> identity;    
        double              minEdep;    
        
    public:
        // infos filled in Sensitive Detector
        inline void SetPos(G4ThreeVector xyz)       { pos.push_back(xyz); }
        inline vector<G4ThreeVector> GetPos()       { return pos; }
        inline G4ThreeVector GetLastPos()           { if(pos.size()) return pos[pos.size()-1];  }
        
        inline void SetLPos(G4ThreeVector xyz)      { Lpos.push_back(xyz); }
        inline vector<G4ThreeVector> GetLPos()      { return Lpos; }
        
        inline void SetVert(G4ThreeVector ver)      { vert.push_back(ver); }
        inline G4ThreeVector GetVert()              { return  vert[0]; }
        inline vector<G4ThreeVector> GetVerts()     { return  vert; }
    
        inline void SetEdep(double depe)            { edep.push_back(depe); }
        inline vector<double> GetEdep()             { return edep; }

        inline void SetDx(double Dx)                { dx.push_back(Dx); }
        inline vector<double> GetDx()               { return dx; }
        
        inline void SetTime(double ctime)           { time.push_back(ctime); }
        inline vector<double> GetTime()             { return  time; }
        
        inline void SetMom(G4ThreeVector pxyz)      { mom.push_back(pxyz); }
        inline G4ThreeVector GetMom()               { return mom[0]; }
        inline vector<G4ThreeVector> GetMoms()      { return mom; }
        
        inline void SetE(double ene)                { E.push_back(ene); }
        inline double GetE()                        { return E[0]; }
        inline vector<double> GetEs()               { return E; }
        
        inline void SetTrackId(int tid)             { trackID.push_back(tid); }
        inline int GetTId()                         { return trackID[0]; }
        inline vector<int> GetTIds()                { return trackID; }
        
        inline vector<identifier> GetId()           { return identity; }
        inline void SetId(vector<identifier> iden)  { identity = iden; }
        
        inline void SetDetector(detector det)       {Detectors.push_back(det);}
        inline vector<detector> GetDetectors()      {return Detectors;}
        inline detector GetDetector()               {return Detectors[0];}
        
        inline void SetThreshold(double E)          { minEdep = E; }
        inline double GetThreshold()                { return minEdep; }

        inline void SetPID(int pid)                 { PID.push_back(pid); }
        inline int GetPID()                         { return PID[0]; }
        inline vector<int> GetPIDs()                { return PID; }
    
        inline void SetCharge(int Q)                { q.push_back(Q); }
        inline int GetCharge()                      { return q[0]; }
        inline vector<int> GetCharges()             { return q; }

        // infos filled in MEvent Action
        inline void SetmTrackId(int tid)            { mtrackID.push_back(tid); }
        inline void SetmTrackIds(vector<int> tid)   { mtrackID = tid; }
        inline int GetmTrackId()                    { return mtrackID[0]; }
        inline vector<int> GetmTrackIds()           { return mtrackID; }
                
        inline void SetmPID(int mpid)               { mPID.push_back(mpid); }
        inline void SetmPIDs(vector<int> mpid)      { mPID = mpid; }
        inline int GetmPID()                        { return mPID[0]; }
        inline vector<int> GetmPIDs()               { return mPID; }
        
        inline void SetmVert(G4ThreeVector ver)          { mvert.push_back(ver); }
        inline void SetmVerts(vector<G4ThreeVector> ver) { mvert = ver; }
        inline G4ThreeVector GetmVert()                  { return  mvert[0]; }
        inline vector<G4ThreeVector> GetmVerts()         { return  mvert; }
        
};


#include "G4THitsCollection.hh"
typedef G4THitsCollection<MHit> MHitCollection;

#endif