SToGS_BaseROOTEvents.h

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_BaseROOTEvents_h
#define SToGS_BaseROOTEvents_h 1

#include "TObject.h"
#include "TClonesArray.h"

#include <list>

class SBRHit : public TObject
{
public:
        Double32_t fE;  // energy
    //
        Int_t fPDG;             // PDG of the particle giving this Hit
    //
        Double32_t fX;  // X position
        Double32_t fY;  // Y position
        Double32_t fZ;  // Z position
        Double32_t fT;  // time of flight
    //
        Int_t fFlag;    // a flag
        Int_t fUID;             // a universal ID
    
public:
    virtual void Clear(Option_t * /*opt*/)
    {
        fE  = 0;
        fPDG = -1;
        fX  = 0.0;
        fY  = 0.0;
        fZ  = 0.0;
        fT  = 0.0;
        fFlag = 0;
        fUID  = -1;
    }
    
public:
        SBRHit();
        SBRHit(const SBRHit &);
        virtual ~SBRHit();
    
        ClassDef( SBRHit , 1 ) // SToGS Basic ROOT  Hit
};


class SBRPHit : public SBRHit
{
public:
    //
        Double32_t fPX; // X Direction
        Double32_t fPY; // Y Direction
        Double32_t fPZ; // Z Direction

public:
        void Clear(Option_t *opt)
    {
        SBRHit::Clear(opt);
        fPX  = 0.0;
        fPY  = 0.0;
        fPZ  = 0.0;
    }
    
public:
        SBRPHit(): SBRHit(), fPX(0.0), fPY(0.0), fPZ(0.0)
    {
        ;
    }
        SBRPHit(const SBRPHit &);
        virtual ~SBRPHit()
    {
        ;
    }
    
        ClassDef( SBRPHit , 1 ) // SToGS Basic Polarized ROOT Hit
};

class SBREvent : public TObject
{
private:
        TClonesArray *fHits; //-> Collection of hits
        
        Double32_t fETot;       // sum energy
        Int_t fMultTot;         // fold
    
public:
        SBREvent();
        virtual ~SBREvent();
        
        // void CopyTo(std::vector <SBRHit *> &ordlist, Option_t *opt = "");
    
        Int_t GetNbHits() const
    {
        return fHits->GetEntries();
    }
        
        SBRHit *IsUID(Int_t uid, Int_t *which = 0x0)
        {
                TClonesArray &ar = *fHits;
        
                SBRHit *ishit = 0x0; Int_t entries = fHits->GetEntries();
                for (Int_t j = 0; j < entries; j++) {
                        SBRHit *hit = (SBRHit *)ar[j];
                        if ( hit->fUID == uid ) {
                                ishit = hit;
                                if ( which )
                                        (*which) = j;
                                break;
                        }
                }
                return ishit;
        }
        
        SBRHit *GetHit(Int_t);
        SBRHit *AddHit();

    void AddHit(const SBRHit *hit);
        
        void AddEMult(Double_t h, Int_t k = 1)
    {
        fETot += h;
        fMultTot += k;
    }
        
        void SetEMult(Double_t h, Int_t k)
    {
        fETot = h;
        fMultTot = k;
    }
        
        Double_t GetETot() const
    {
        return fETot;
    }
        Int_t GetMultTot() const
    {
        return fMultTot;
    }
        
        virtual void Clear(Option_t *opt);
        
        ClassDef( SBREvent , 1 ) // SToGS Basic ROOT Event
};

class SBRPEvent : public TObject
{
private:
        TClonesArray *fHits; //-> Collection of hits
        
        Double32_t fETot;       // sum energy
        Int_t fMultTot;         // fold
    
public:
        SBRPEvent();
        virtual ~SBRPEvent();
        
        // void CopyTo(std::vector <SBRPHit *> &ordlist, Option_t *opt = "");
    
        Int_t GetNbHits() const
    {
        return fHits->GetEntries();
    }
        
        SBRPHit *IsUID(Int_t uid, Int_t *which = 0x0)
        {
                TClonesArray &ar = *fHits;
        
                SBRPHit *ishit = 0x0; Int_t entries = fHits->GetEntries();
                for (Int_t j = 0; j < entries; j++) {
                        SBRPHit *hit = (SBRPHit *)ar[j];
                        if ( hit->fUID == uid ) {
                                ishit = hit;
                                if ( which )
                                        (*which) = j;
                                break;
                        }
                }
                return ishit;
        }
        
        SBRPHit *GetHit(Int_t);
        SBRPHit *AddHit();
        
        void AddEMult(Double_t h, Int_t k = 1)
    {
        fETot += h;
        fMultTot += k;
    }
        
        void SetEMult(Double_t h, Int_t k)
    {
        fETot = h;
        fMultTot = k;
    }
        
        Double_t GetETot() const
    {
        return fETot;
    }
        Int_t GetMultTot() const
    {
        return fMultTot;
    }
        
        virtual void Clear(Option_t *opt);
        
        ClassDef( SBRPEvent , 1 ) // SToGS Basic Polarised ROOT Event
};


class SBROpticalHit : public TObject
{
public:
        Double32_t fX;  // X position of the last point of the track
        Double32_t fY;  // Y position of the last point of the track
        Double32_t fZ;  // Z position of the last point of the track
        Double32_t fTA; // arrival time for the last point of the track since event
        Double32_t fTL; // arrival time for the last point of the track since creation of the photon
        
        Double32_t fLength; // length of the trace
        
        Int_t fPrimaryID;       // Primary ID, in case more that one primary particle is giving scintillation
        Int_t fSecondaryID;     // detector ID where the optical photon is
        Int_t fNbSteps;         // number of steps between start and stop
        
private:
        void Clear(Option_t *opt);
        
public:
        SBROpticalHit();
        SBROpticalHit(const SBROpticalHit &);
        virtual ~SBROpticalHit();
        
        ClassDef( SBROpticalHit , 1 ) // SToGS Optical Hit
};

class SBROpticalEvent : public TObject
{
private:
        TClonesArray *fHits; //-> Collection of optical hits
        
public:
        SBROpticalEvent();
        virtual ~SBROpticalEvent();
    
        // number of hits in that event
        Int_t GetNbHits() const
    {
        return fHits->GetEntries();
    }
        
        SBROpticalHit *GetHit(Int_t);
        SBROpticalHit *AddHit();
        
        void Clear(Option_t *opt);
    
        ClassDef( SBROpticalEvent , 1 ) // SToGS Optical Event
};

#endif