TRestDetectorHitsEvent.h

 
#ifndef TRestSoft_TRestDetectorHitsEvent
#define TRestSoft_TRestDetectorHitsEvent
 
#include <TAxis.h>
#include <TGraph.h>
#include <TGraph2D.h>
#include <TH2F.h>
#include <TMath.h>
#include <TRestEvent.h>
#include <TRestHits.h>
#include <TVector3.h>
 
#include <iostream>
 
class TRestDetectorHitsEvent : public TRestEvent {
   private:
    TRestHits* fXZHits;  
    TRestHits* fYZHits;  
 
    TRestHits* fXYZHits;  
 
   protected:
    // TODO These graphs should be placed in TRestHits?
    // (following similar GetGraph implementation in TRestDetectorSignal)
 
    TGraph* fXYHitGraph;  
    TGraph* fXZHitGraph;  
    TGraph* fYZHitGraph;  
 
    TH2F* fXYHisto;  
    TH2F* fYZHisto;  
    TH2F* fXZHisto;  
 
    TH1F* fXHisto;  
    TH1F* fYHisto;  
    TH1F* fZHisto;  
 
    TRestHits* fHits;  //->
 
   public:
    void AddHit(Double_t x, Double_t y, Double_t z, Double_t en, Double_t t = 0, REST_HitType type = XYZ);
    void AddHit(const TVector3& position, Double_t energy, Double_t time, REST_HitType type = XYZ);
 
    void Sort(bool(compareCondition)(const TRestHits::iterator& hit1,
                                     const TRestHits::iterator& hit2) = nullptr);
    void Shuffle(int NLoop);
 
    inline size_t GetNumberOfHits() const { return fHits->GetNumberOfHits(); }
 
    inline TRestHits* GetHits() const { return fHits; }
 
    inline Double_t GetX(int n) const { return fHits->GetX(n); }
 
    inline Double_t GetY(int n) const { return fHits->GetY(n); }
 
    inline Double_t GetZ(int n) const { return fHits->GetZ(n); }
 
    inline REST_HitType GetType(int n) const { return fHits->GetType(n); }
 
    inline Double_t GetDistance2(int n, int m) const { return fHits->GetDistance2(n, m); }
 
    TRestHits* GetXZHits();
    TRestHits* GetYZHits();
    TRestHits* GetXYZHits();
 
    virtual void Initialize();
 
    inline virtual void PrintEvent() const { TRestDetectorHitsEvent::PrintEvent(-1); };
    virtual void PrintEvent(Int_t nHits) const;
 
    inline TVector3 GetPosition(int n) const { return fHits->GetPosition(n); }
 
    inline TVector3 GetMeanPosition() const { return fHits->GetMeanPosition(); }
 
    inline Int_t GetNumberOfHitsX() const { return fHits->GetNumberOfHitsX(); }
    inline Int_t GetNumberOfHitsY() const { return fHits->GetNumberOfHitsY(); }
 
    inline Double_t GetMeanPositionX() const { return fHits->GetMeanPositionX(); }
    inline Double_t GetMeanPositionY() const { return fHits->GetMeanPositionY(); }
    inline Double_t GetMeanPositionZ() const { return fHits->GetMeanPositionZ(); }
    inline Double_t GetSigmaXY2() const { return fHits->GetSigmaXY2(); }
    inline Double_t GetSigmaX() const { return fHits->GetSigmaX(); }
    inline Double_t GetSigmaY() const { return fHits->GetSigmaY(); }
 
    inline Double_t GetGaussSigmaX(Double_t error, Int_t nHitsMin) {
        return GetXZHits()->GetGaussSigmaX(error, nHitsMin);
    }
    inline Double_t GetGaussSigmaY(Double_t error, Int_t nHitsMin) {
        return GetYZHits()->GetGaussSigmaY(error, nHitsMin);
    }
    inline Double_t GetGaussSigmaZ(Double_t error, Int_t nHitsMin) const {
        return fHits->GetGaussSigmaZ(error, nHitsMin);
    }
 
    inline Double_t GetSigmaZ2() const { return fHits->GetSigmaZ2(); }
    inline Double_t GetSkewXY() const { return fHits->GetSkewXY(); }
    inline Double_t GetSkewZ() const { return fHits->GetSkewZ(); }
 
    inline Double_t GetMaximumHitEnergy() const { return fHits->GetMaximumHitEnergy(); }
    inline Double_t GetMinimumHitEnergy() const { return fHits->GetMinimumHitEnergy(); }
    inline Double_t GetMeanHitEnergy() const { return fHits->GetMeanHitEnergy(); }
 
    inline Double_t GetEnergyX() const { return fHits->GetEnergyX(); }
    inline Double_t GetEnergyY() const { return fHits->GetEnergyY(); }
    inline Double_t GetTotalEnergy() const { return fHits->GetTotalEnergy(); }
    inline Double_t GetEnergy() const { return fHits->GetTotalEnergy(); }
 
    inline Double_t GetEnergy(int n) const { return fHits->GetEnergy(n); }
    inline Double_t GetTime(int n) const { return GetHits()->GetTime(n); }  // return value in us
 
    inline Int_t GetClosestHit(const TVector3& position) const { return fHits->GetClosestHit(position); }
 
    // Inside Cylinder methods
    Bool_t anyHitInsideCylinder(TVector3 x0, TVector3 x1, Double_t radius);
    Bool_t allHitsInsideCylinder(TVector3 x0, TVector3 x1, Double_t radius);
    Double_t GetEnergyInCylinder(TVector3 x0, TVector3 x1, Double_t radius);
    Int_t GetNumberOfHitsInsideCylinder(TVector3 x0, TVector3 x1, Double_t radius);
    TVector3 GetMeanPositionInCylinder(TVector3 x0, TVector3 x1, Double_t radius);
 
    // Inside Prim methods
    Bool_t anyHitInsidePrism(TVector3 x0, TVector3 x1, Double_t sizeX, Double_t sizeY, Double_t theta);
    Bool_t allHitsInsidePrism(TVector3 x0, TVector3 x1, Double_t sX, Double_t sY, Double_t theta);
 
    Double_t GetEnergyInPrism(TVector3 x0, TVector3 x1, Double_t sizeX, Double_t sizeY, Double_t theta);
    Int_t GetNumberOfHitsInsidePrism(TVector3 x0, TVector3 x1, Double_t sizeX, Double_t sizeY,
                                     Double_t theta);
    TVector3 GetMeanPositionInPrism(TVector3 x0, TVector3 x1, Double_t sizeX, Double_t sizeY, Double_t theta);
 
    // Get distance to cylinder walls methods
    Double_t GetClosestHitInsideDistanceToCylinderWall(TVector3 x0, TVector3 x1, Double_t radius);
    Double_t GetClosestHitInsideDistanceToCylinderTop(TVector3 x0, TVector3 x1, Double_t radius);
    Double_t GetClosestHitInsideDistanceToCylinderBottom(TVector3 x0, TVector3 x1, Double_t radius);
 
    // Get distance to prism walls methods
    Double_t GetClosestHitInsideDistanceToPrismWall(TVector3 x0, TVector3 x1, Double_t sizeX, Double_t sizeY,
                                                    Double_t theta);
    Double_t GetClosestHitInsideDistanceToPrismTop(TVector3 x0, TVector3 x1, Double_t sizeX, Double_t sizeY,
                                                   Double_t theta);
    Double_t GetClosestHitInsideDistanceToPrismBottom(const TVector3& x0, const TVector3& x1, Double_t sizeX,
                                                      Double_t sizeY, Double_t theta);
 
    TPad* DrawEvent(const TString& option = "");
 
    TH2F* GetXYHistogram(std::vector<float> ranges, Double_t pitch = 3, Double_t border = 5);
    TH2F* GetXZHistogram(std::vector<float> ranges, Double_t pitch = 3, Double_t border = 5);
    TH2F* GetYZHistogram(std::vector<float> ranges, Double_t pitch = 3, Double_t border = 5);
 
    void DrawHistograms(Int_t& column, const TString& histOption = "", double pitch = 0);
    void DrawGraphs(Int_t& column);
 
    // Constructor
    TRestDetectorHitsEvent();
    // Destructor
    ~TRestDetectorHitsEvent();
 
    ClassDef(TRestDetectorHitsEvent, 1);
};
#endif