AlfaLocalHits.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AlfaLocalHits_h
#define AlfaLocalHits_h
 
 
// ROOT headers
#include "CLHEP/Geometry/Point3D.h"
#include "TString.h"
#include <vector>
class ALFA_LocRecCorrEvent;
 
 
 
 
//
//   user class to store ONE local hit
//
class AlfaLocalHit{
    private:
        int m_pot = 0;
        TString m_potname;
        int m_ishit = 0;
        Float_t m_x = 0.0F, m_y = 0.0F, m_z = 0.0F;
        const ALFA_LocRecCorrEvent * m_LocRecCorr = nullptr;
    public:
        AlfaLocalHit();
        AlfaLocalHit(const ALFA_LocRecCorrEvent * LocRecCorrHit);
        AlfaLocalHit(const AlfaLocalHit * h);
        void    SetHit(const ALFA_LocRecCorrEvent * LocRecCorrHit); 
        void    AssignZ();
        int     GetPotNum() const {return m_pot;};
        float   GetX() const {return m_x;};
        float   GetY() const {return m_y;};
        float   GetZ() const {return m_z;};
        int     IsHi() const {return m_ishit;};
        int     GetMDindex(const char * name);
        TString GetPotName() const {return m_potname;};
        TString GetMDname (int i);
        const ALFA_LocRecCorrEvent * GetLocRecCorr() const {return m_LocRecCorr;};
        void    Print();
};
 
//
//    user class to store MULTIPLE local hits
//    inherits from AlfaLocalHit
//
//    from such a collection of hits one can 
//    select global track candidates by means
//    of applying "paths", i.e. B7L1U_A7L1U_X_X etc.
//
class AlfaLocalHits : public AlfaLocalHit {
    private:
                std::vector<AlfaLocalHit> m_hits;
        int  m_nhits;
                std::vector<AlfaLocalHits> m_paths;
        int  m_npaths;
        TString m_pathpattern;
    public:
        AlfaLocalHits(); // .. default ctor.
        void update();
        int  AddHit(const AlfaLocalHit& h);
        void Reset();
        void ResetPaths();
        int  size();
        int  GetNhits() {return m_nhits;}
        int  GetNpaths(){return m_npaths;}
        void Dump();
        void DumpPaths();
        void ApplyPathPattern(const char * pattern);
        AlfaLocalHits * GetPathHits(int ipath);
        AlfaLocalHit  * GetHit(int ihit);
        void    SetPathPattern(const char * pattern);
        TString GetPathPattern(){return m_pathpattern;}
};
 
 
 
//
//    user class to store one track candidate
//
class AlfaTrackCand {
    private:
        int  m_arm;
        float m_x, m_y, m_z;
        float m_xslope, m_yslope;
        AlfaLocalHits * m_trackcandhits;
        AlfaLocalHit  * m_nearlocalhit;
        AlfaLocalHit  * m_farlocalhit;
        HepGeom::Point3D<double> m_nearimpactpoint;
        HepGeom::Point3D<double> m_farimpactpoint;
    public:
        AlfaTrackCand(AlfaLocalHits * hits); // .. explicit ctor.
        int IsLeftTrack();
        int IsRightTrack();
        int IsLowerArmTrack();
        int IsUpperArmTrack();
        int IsValidTrack() {return (m_nearlocalhit && m_farlocalhit);};
        int IsLeftOrRightTrack();
        int IsLeftAndRightTrack();
        void CalcTrack();
        int   GetArmNum(){return m_arm;};
        float GetX(){return m_x;};
        float GetY(){return m_y;};
        float GetZ(){return m_z;};
        float GetXslope(){return m_xslope;};
        float GetYslope(){return m_yslope;};
        AlfaLocalHit * GetNearLocalHit(){return m_nearlocalhit;};
        AlfaLocalHit * GetFarLocalHit() {return m_farlocalhit; };
        const ALFA_LocRecCorrEvent * GetNearLocRecCorr() const {return m_nearlocalhit->GetLocRecCorr();};
        const ALFA_LocRecCorrEvent * GetFarLocRecCorr() const {return m_farlocalhit->GetLocRecCorr();}
        void CalcImpactPoints();
        HepGeom::Point3D<double> * GetNearImpactPoint(){return &m_nearimpactpoint;};
        HepGeom::Point3D<double> * GetFarImpactPoint(){return &m_farimpactpoint;};
        void Dump() const;
};
 
 
 
#endif // AlfaLocalHits_h