Track.h

Go to the documentation of this file.

 
#ifndef _TRACK_H_
#define _TRACK_H_
 
//----------------//
//   C++ StdLib   //
//----------------//
#include <cstdio>
#include <vector>
#include <cmath>
 
//----------//
//   ROOT   //
//----------//
#include "TObject.h"
#include "TClonesArray.h"
#include "TRefArray.h"
#include "TRef.h"
 
 
//TODO static?
namespace TRACKINFO {
    enum STRATEGY  {MATCH = 0, S345, S456, S123C4, S123C5, GBL};
}
namespace TRACKINFO {…}
 
class Track : public TObject {
 
    public:
 
        Track();
 
        ~Track();
 
        void Clear(Option_t *option="");
 
        void addHit(TObject* hit); 
        
        void setTruthLink(TObject* obj) {truth_link_ = obj;};
        TRef getTruthLink() {return truth_link_;}
        
        TRefArray getSvtHits() const { return tracker_hits_; };
        
        void setTrackParameters(const double d0, 
                                const double phi0, 
                                const double omega, 
                                const double tan_lambda,
                                const double z0);
        
        std::vector<double> getTrackParameters(); 
        
        
        double getD0       () const {return d0_;}
        double getPhi      () const {return phi0_;}
        void   setPhi      (const double phi0) {phi0_ = phi0;}
        double getOmega    () const {return omega_;}
        double getTanLambda() const {return tan_lambda_;}
        double getZ0       () const {return z0_;}
        
        void setCov(const std::vector<float>& cov) {cov_ = cov;}
        
        std::vector<float> getCov() {return cov_;}
 
        std::vector<int> getHitLayers() {return hit_layers_;}
        void addHitLayer(int layer) {hit_layers_.push_back(layer);}
        
        void addMcpHit(int layer, int mcpID) {mcp_hits_.push_back(std::make_pair(layer,mcpID));}
        std::vector<std::pair<int,int>> getMcpHits() {return mcp_hits_;}
        
        double getD0Err () const {return sqrt(cov_[0]);}
        double getPhiErr () const {return sqrt(cov_[2]);}
        double getOmegaErr () const {return sqrt(cov_[5]);}
        double getTanLambdaErr () const {return sqrt(cov_[14]);}
        double getZ0Err() const {return sqrt(cov_[9]);}
        //double getPtErr() const { return pt_err;}
 
        void setNdf(const float ndf) {ndf_ = ndf;}
        double getNdf() const {return ndf_;}
 
        void setChi2(const double chi2) { chi2_ = chi2; };
 
        double getChi2() const { return chi2_; };
 
        double getChi2Ndf() const { 
            //avoid check for 0
            if (ndf_ > 1e-6) 
                return chi2_ / ndf_;
            else  
                return -999;
        };
        double getChi2Ndf() const  {…}
 
        void setIsolation(const int layer, const double isolation) { isolation_[layer] = isolation; };
 
 
        double getIsolation(const int layer) const { return isolation_[layer]; }; 
 
 
        void setTrackTime(const double track_time) { track_time_ = track_time; };
 
        double getTrackTime() const { return track_time_; }; 
 
        void setTrackVolume(const int track_volume) { track_volume_ = track_volume; };
 
        void setParticle(TObject* particle) { particle_ = particle; };
 
        TObject* getParticle() const { return static_cast<TObject*>(particle_.GetObject()); }; 
 
        void setPositionAtEcal(const double* position);
 
        std::vector<double> getPositionAtEcal(); 
 
        void setPosition(const double* position);
 
        std::vector<double> getPosition(); 
 
        void setType(const int type) { type_ = type; }; 
 
        int getType() const { return type_; }; 
 
        //Run Dependent Corrections
        void applyCorrection(std::string var, double correction);
 
        //bit1
        bool is345Seed     () const  { return   ((type_  >> 1) & 0x1);}
 
        bool is456Seed     () const  { return   ((type_  >> 2) & 0x1);}
 
        bool is123SeedC4   () const  { return   ((type_  >> 3) & 0x1);}
 
        bool is123SeedC5   () const  { return   ((type_  >> 4) & 0x1);}
 
        bool isMatchedTrack() const  { return    (type_ & 0x1);}
 
        bool isGBLTrack    () const  { return   ((type_ >> 5)  & 0x1);}
        
        bool isKalmanTrack () const  { return   type_ == 1 ; }
 
        bool isStrategy(TRACKINFO::STRATEGY strategy) {return (type_ >> strategy) & 0x1;};
 
        void setCharge(const int charge) { charge_ = charge; };
 
        int getCharge() const { return charge_; };  
 
 
        void setID(const int id){id_ = id;};
        
        int getID() const {return id_;};
 
 
        void setMomentum(double bfield = 0.52);
        
 
        void setMomentum(std::vector<double> momentum); 
 
        void setMomentum(double px, double py, double pz);
 
        std::vector<double> getMomentum() { return {px_, py_, pz_}; }; 
        
        double getP() const {return sqrt(px_*px_ + py_*py_ + pz_*pz_);};
        
        double getPt() const {return sqrt(px_*px_ + py_*py_);}
        
        void setLambdaKink(const int layer, const double lambda_kink) { lambda_kinks_[layer] = lambda_kink; }
        
        double getLambdaKink(const int layer) const { return lambda_kinks_[layer]; }
        
        void setPhiKink(const int layer, const double phi_kink) { phi_kinks_[layer] = phi_kink; }
 
        double getPhiKink(const int layer) const { return phi_kinks_[layer]; }
 
        bool isTopTrack() const { return track_volume_ ? false : true; };
 
        bool isBottomTrack() const { return track_volume_ ? true : false; };
 
        void setTrackerHitCount(int nHits) { n_hits_ = nHits; };
 
        int getTrackerHitCount() const { return n_hits_; };
 
        void setNShared(const int nShared) { nShared_ = nShared;};
 
        int getNShared() const {return nShared_;};
 
        void setSharedLy0(const bool isShared) {SharedLy0_ = isShared;};
        void setSharedLy1(const bool isShared) {SharedLy1_ = isShared;};
 
        bool getSharedLy0() const {return SharedLy0_;};
        bool getSharedLy1() const {return SharedLy1_;};
 
 
        //TODO doc
 
        void Print (Option_t *option="") const;
 
    private:
 
        TRefArray tracker_hits_{TRefArray{}};
 
        TRef particle_;
 
        double isolation_[14];
 
        int n_hits_{0}; 
 
        int track_volume_{-999}; 
 
        int type_{-999}; 
 
        std::vector<float> cov_;
 
        std::vector<int> hit_layers_;
 
        std::vector<std::pair<int,int>> mcp_hits_;
 
        double d0_{-999.}; 
 
        double phi0_{-999.};
 
        double omega_{-999.}; 
 
        double tan_lambda_{-999.};
 
        double z0_{-999.}; 
 
        double chi2_{-999.};
 
        double ndf_{0.};
 
        double track_time_{-999.};
 
        double x_at_ecal_{-999.};
 
        double y_at_ecal_{-999.};
 
        double z_at_ecal_{-999.};
 
        double x_{-999.};
 
        double y_{-999.};
 
        double z_{-999.};
 
        double lambda_kinks_[14];  
 
        double phi_kinks_[14];  
 
        double px_{-9999.}; 
        double py_{-9999.}; 
        double pz_{-9999.};
                
        int id_{0};
 
        int charge_{0};
 
        int nShared_{0};
 
        bool SharedLy0_{false};
        
        bool SharedLy1_{false};
        
        TRef truth_link_;
        
        TRef mcp_link_;
        
        ClassDef(Track, 1);
}; // Track
class Track : public TObject {…};
 
#endif // __TRACK_H__