track.hh

Go to the documentation of this file.

#ifndef TRACK_HH
#define TRACK_HH

#include "data_base.hh"
#include "TVector3.h"
#include "TMatrixD.h"

namespace larlight {
  class track : public data_base {
    
  public:
    
    track(DATA::DATA_TYPE type=DATA::Track);
    
    track(const track& original);
    
    virtual ~track(){}
    
    inline Int_t     track_id      ()               const { return fID;                  }
    inline size_t    n_point       ()               const { return fDir.size();          }
    inline size_t    n_covariance  ()               const { return fCov.size();          }
    inline size_t    n_momentum    ()               const { return fFitMomentum.size();  }
    inline size_t    n_dQdx        ()               const { return fdQdx.size();         }
    
    inline const TVector3& direction_at  (UInt_t p) const { return fDir.at(p);           }
    inline const TVector3& vertex_at     (UInt_t p) const { return fXYZ.at(p);           }
    inline       Double_t    momentum_at (UInt_t p) const { return fFitMomentum.at(p);   }
    inline const TMatrixD& covariance_at (UInt_t p) const { return fCov.at(p);           }
    
    inline void set_track_id   (const Int_t id)     { fID = id;                  }
    inline void add_vertex     (const TVector3 v) { fXYZ.push_back(v);         }
    inline void add_direction  (const TVector3 v) { fDir.push_back(v);         }
    inline void add_momentum   (const Double_t   v) { fFitMomentum.push_back(v); }
    inline void add_covariance (const TMatrixD m) { fCov.push_back(m);         }
    
    virtual void clear_data();
    
    void get_axis_range (Double_t &max, Double_t &min, const Int_t axis) const;
    
    void get_axis_range (Double_t &xmax, Double_t &xmin,
             Double_t &ymax, Double_t &ymin,
             Double_t &zmax, Double_t &zmin) const;  
    
    
  protected:
    
    Int_t fID;            
    
    std::vector<TVector3> fXYZ;
    
    std::vector<TVector3> fDir;
    
    std::vector<TMatrixD> fCov;
    
    std::vector< std::vector <Double_t> > fdQdx;
    
    std::vector<Double_t> fFitMomentum;
    
  private:
    
    
    ClassDef(track,2)
      
  };

  class event_track : public std::vector<larlight::track>, public event_base {
    
  public:
    
    event_track(DATA::DATA_TYPE type=DATA::Track);
    
    event_track(const event_track& original) : std::vector<larlight::track>(original),
                           event_base(original)
    {}
    
    ~event_track(){}
    
    virtual void clear_data(){event_base::clear_data(); clear();}
    
    void get_axis_range (Double_t &max, Double_t &min, const Int_t axis) const;
    
    void get_axis_range (Double_t &xmax, Double_t &xmin,
             Double_t &ymax, Double_t &ymin,
             Double_t &zmax, Double_t &zmin) const;  
    
  private:
    
    ClassDef(event_track,3)
  };
}
#endif
 // end of doxygen group 

---