Hit.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"
#include "sensitiveID.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();
        
        G4Colour colour_touch, colour_hit, colour_passby;
        
    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<int>        otrackID;    
        vector<G4ThreeVector> mvert;    
        vector<string> materialName;    
        vector<int>     processID;     
    
        vector<detector>  Detectors;    
        
        vector<identifier> identity;    
        sensitiveID SID;                
            
        vector<double> signalT;         
        vector<double> signalV;         

        vector<int> quantumT;           
        vector<int> quantumQ;           
        vector<int> quantumTR;          

        int hasTrigger;                 
    
    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]; else return G4ThreeVector(0,0,0); }
        
        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 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 SetoTrackId(int tid)            { otrackID.push_back(tid); }
        inline void SetoTrackIds(vector<int> tid)   { otrackID = tid; }
        inline int GetoTrackId()                    { return otrackID[0]; }
        inline vector<int> GetoTrackIds()           { return otrackID; }

        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; }
    
        inline void SetMatName(string mname)           { materialName.push_back(mname); }
        inline void SetMatNames(vector<string> mnames) { materialName = mnames; }
        inline string GetMatName()                     { return  materialName[0]; }
        inline vector<string> GetMatNames()            { return  materialName; }

        inline void SetProcID(int procID)          { processID.push_back(procID); }
        inline void SetProcID(vector<int> procIDs) { processID = procIDs; }
        inline int GetProcID()                     { return  processID[0]; }
        inline vector<int> GetProcIDs()            { return  processID; }

        inline void SetSDID(sensitiveID s)   { SID = s; }
        inline sensitiveID GetSDID()         { return SID; }


        inline void setSignal(map< double, double > VT)
        {
            signalT.clear();
            signalV.clear();
            
            for(map< double, double >::iterator it = VT.begin(); it!=VT.end(); it++)
            {
                signalT.push_back(it->first);
                signalV.push_back(it->second);
            }
        }
    
        inline vector<double> getSignalT(){return signalT;}
        inline vector<double> getSignalV(){return signalV;}

    inline void setQuantum(map< int, int > QS)
    {
        quantumT.clear();
        quantumQ.clear();
        
        for(map< int, int >::iterator it = QS.begin(); it!=QS.end(); it++)
        {
            quantumT.push_back(it->first);
            quantumQ.push_back(it->second);
        }
    }
    
    inline vector<int> getQuantumT() {return quantumT;}
    inline vector<int> getQuantumQ() {return quantumQ;}
    inline vector<int> getQuantumTR(){return quantumTR;}
    inline void setQuantumTR(vector<int> t)   { quantumTR = t; }
    
    // trigger
    inline void passedTrigger(){hasTrigger = 1;}
    inline int diditpassTrigger(){return hasTrigger;}
    
    
};


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

#endif