CbmTofTracklet.h

Go to the documentation of this file.

 
#ifndef CBMTOFTRACKLET_H
#define CBMTOFTRACKLET_H 1
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Int_t, Double_t, Bool_t, Option_t
#include <TMath.h>       // for Sqrt, ATan, Power
#include <TObject.h>     // for TObject
 
#include <FairTrackParam.h>  // for FairTrackParam
 
#include <vector>  // for vector, __vector_base<>::value_type
 
#include "CbmTofHit.h"            // for CbmTofHit
#include "CbmTofTrackletParam.h"  // for CbmTofTrackletParam
 
class CbmTofTracklet : public TObject {
 
public:
  CbmTofTracklet();
 
  virtual ~CbmTofTracklet();
 
  virtual void PrintInfo();
 
  Int_t GetPidHypo() const { return fPidHypo; }
 
  Int_t GetNofHits() const { return fTofHit.size(); }
 
  Int_t GetHitIndex(Int_t ind) const { return fTofHit[ind]; }
 
  Double_t GetT0() const { return fT0; }
  Double_t GetTt() const { return fTt; }
  Double_t GetT0Err() const { return fT0Err; }
  Double_t GetTtErr() const { return fTtErr; }
  Double_t GetT0TtCov() const { return fT0TtCov; }
  Double_t GetTheta() const {
    return TMath::ATan(TMath::Sqrt(TMath::Power(fTrackPar.GetTy(), 2)
                                   + TMath::Power(fTrackPar.GetTx(), 2)));
  }
  Double_t GetPhi() const {
    return TMath::ATan(fTrackPar.GetTy() / fTrackPar.GetTx());
  }
  Int_t GetStationHitIndex(Int_t iSm) const {
    for (Int_t i = 0; i < (Int_t) fTofHit.size(); i++)
      if (fTofDet[i] == iSm) return fTofHit[i];
    return -1;
  }
 
  Int_t GetTofHitIndex(Int_t ind) const { return fTofHit[ind]; }
  CbmTofHit* GetTofHitPointer(Int_t ind) { return &fhit[ind]; }
  Int_t GetTofDetIndex(Int_t ind) const { return fTofDet[ind]; }
 
  const std::vector<Int_t>& GetTofHitInd() const { return fTofHit; }
 
  const Double_t*
  GetPoint(Int_t n);  // interface to event display: CbmEvDisTracks
  const Double_t*
  GetFitPoint(Int_t n);  // interface to event display: CbmEvDisTracks
 
  Double_t GetTrackDx() const {
    return TMath::Sqrt(fTrackPar.GetCovariance(0));
  }
 
  Double_t GetTrackDy() const {
    return TMath::Sqrt(fTrackPar.GetCovariance(5));
  }
 
  Double_t GetTrackLength() const { return fTrackLength; }
 
  CbmTofTrackletParam* GetTrackParameter() { return &fTrackPar; }
 
  Double_t GetTrackX() const { return fTrackPar.GetX(); }
 
  Double_t GetTrackY() const { return fTrackPar.GetY(); }
 
  Double_t GetTrackTx() const { return fTrackPar.GetTx(); }
 
  Double_t GetTrackTy() const { return fTrackPar.GetTy(); }
 
  Double_t GetDistance() const { return fDistance; }
  Double_t GetTime() const { return fTime; }
  Double_t UpdateTt();
  Double_t UpdateT0();
  Double_t GetTex(CbmTofHit* pHit);
 
  Int_t
  GetFirstInd(Int_t iSmType);  // return closest Hit to target except in iSmType
  Double_t GetZ0x();           // return intercept with z-axis
  Double_t GetZ0y();           // return intercept with z-axis
  Double_t GetR0();            // return transverse distance at z=0
  Double_t GetFitX(Double_t Z);  // get x value of fit function at position z
  Double_t GetFitY(Double_t Z);  // get y value of fit function at position z
  Double_t GetFitT(Double_t R);  // get time of fit function at distance R
  Double_t GetRefVel(UInt_t N);  // get reference velocity from first N hits
 
  Double_t GetChiSq() const { return fChiSq; }
  Int_t GetNDF() const { return fNDF; }
 
  const FairTrackParam* GetParamFirst() const { return &fParamFirst; }
  const FairTrackParam* GetParamLast() const { return &fParamLast; }
 
  virtual void GetFairTrackParamLast();
 
  virtual Double_t GetMatChi2(Int_t iSm);
 
  inline void SetTofHitIndex(Int_t tofHitIndex, Int_t iDet, CbmTofHit* pHit) {
    fTofHit.resize(1);
    fTofHit[0] = tofHitIndex;
    fTofDet.resize(1);
    fTofDet[0] = iDet;
    fhit.resize(1);
    fhit[0] = CbmTofHit(*pHit);
    fMatChi.resize(1);
  }
 
  inline void SetTofHitIndex(Int_t tofHitIndex,
                             Int_t iDet,
                             CbmTofHit* pHit,
                             Double_t chi2) {
    fTofHit.resize(1);
    fTofHit[0] = tofHitIndex;
    fTofDet.resize(1);
    fTofDet[0] = iDet;
    fhit.resize(1);
    fhit[0] = CbmTofHit(*pHit);
    fMatChi.resize(1);
    fMatChi[0] = chi2;
  }
 
  inline void SetTofHitInd(const std::vector<Int_t>& tofHitInd) {
    fTofHit = tofHitInd;
  }
 
 
  inline void AddTofHitIndex(Int_t tofHitIndex, Int_t iDet, CbmTofHit* pHit) {
    fTofHit.resize(fTofHit.size() + 1);
    fTofHit[fTofHit.size() - 1] = tofHitIndex;
    fTofDet.resize(fTofHit.size());
    fTofDet[fTofHit.size() - 1] = iDet;
    fhit.resize(fTofHit.size());
    fhit[fTofHit.size() - 1] = CbmTofHit(*pHit);
    fMatChi.resize(fTofHit.size());
  }
 
  inline void AddTofHitIndex(Int_t tofHitIndex,
                             Int_t iDet,
                             CbmTofHit* pHit,
                             Double_t chi2) {
    fTofHit.resize(fTofHit.size() + 1);
    fTofHit[fTofHit.size() - 1] = tofHitIndex;
    fTofDet.resize(fTofHit.size());
    fTofDet[fTofHit.size() - 1] = iDet;
    fhit.resize(fTofHit.size());
    fhit[fTofHit.size() - 1] = CbmTofHit(*pHit);
    fMatChi.resize(fTofHit.size());
    fMatChi[fTofHit.size() - 1] = chi2;
  }
 
  inline void ReplaceTofHitIndex(Int_t tofHitIndex,
                                 Int_t iDet,
                                 CbmTofHit* pHit,
                                 Double_t chi2) {
    for (Int_t iHit = 0; iHit < (Int_t) fTofHit.size(); iHit++) {
      if (iDet == fTofDet[iHit]) {
        fTofHit[iHit] = tofHitIndex;
        fhit[iHit]    = CbmTofHit(*pHit);
        fMatChi[iHit] = chi2;
        break;
      }
    }
  }
 
  inline void RemoveTofHitIndex(Int_t /*tofHitIndex*/,
                                Int_t iDet,
                                CbmTofHit* /*pHit*/,
                                Double_t /*chi2*/) {
    for (Int_t iHit = 0; iHit < (Int_t) fTofHit.size(); iHit++) {
      if (iDet == fTofDet[iHit]) {
        fTofHit.erase(fTofHit.begin() + iHit);
        fhit.erase(fhit.begin() + iHit);
        fMatChi.erase(fMatChi.begin() + iHit);
        break;
      }
    }
  }
 
  virtual Double_t GetXdif(Int_t iSmType, CbmTofHit* pHit);
  virtual Double_t GetYdif(Int_t iSmType, CbmTofHit* pHit);
  virtual Double_t GetTdif(Int_t iSmType, CbmTofHit* pHit);
  virtual Double_t Dist3D(CbmTofHit* pHit0, CbmTofHit* pHit1);
  virtual Bool_t ContainsAddr(Int_t iAddr);
  virtual Int_t HitIndexOfAddr(Int_t iAddr);
  virtual CbmTofHit* HitPointerOfAddr(Int_t iAddr);
 
  inline void SetTrackParameter(CbmTofTrackletParam* par) { fTrackPar = *par; }
 
  inline void SetTrackLength(Double_t trackLength) {
    fTrackLength = trackLength;
  }
 
  inline void SetPidHypo(Int_t pid) { fPidHypo = pid; }
 
  inline void SetDistance(Double_t distance) { fDistance = distance; }
  inline void SetTime(Double_t val) { fTime = val; }
  inline void SetTt(Double_t val) { fTt = val; }
  inline void SetT0(Double_t val) { fT0 = val; }
  inline void SetT0Err(Double_t val) { fT0Err = val; }
  inline void SetTtErr(Double_t val) { fTtErr = val; }
  inline void SetT0TtCov(Double_t val) { fT0TtCov = val; }
 
  inline void SetChiSq(Double_t chiSq) { fChiSq = chiSq; }
  inline void SetNDF(Int_t ndf) { fNDF = ndf; }
  inline void SetParamFirst(const FairTrackParam* par) { fParamFirst = *par; }
  inline void SetParamLast(const FairTrackParam* par) { fParamLast = *par; }
 
  void SetParamLast(const CbmTofTrackletParam* par);
  //    void LoadParamLast();
 
  void Clear(Option_t* option = "");
  CbmTofTracklet(const CbmTofTracklet&); 
private:
  Double_t fTrackLength;  
  Int_t fPidHypo;         
  Double_t fDistance;     
  Double_t fTime;         
  Double_t fTt;           
  Double_t fT0;           
  Double_t fT0Err;        
  Double_t fTtErr;        
  Double_t fT0TtCov;      
  Double_t fChiSq;        
  Int_t fNDF;             
  CbmTofTrackletParam fTrackPar;  
  FairTrackParam
    fParamFirst;              
  FairTrackParam fParamLast;  
  std::vector<Int_t> fTofHit;     
  std::vector<Int_t> fTofDet;     
  std::vector<Double_t> fMatChi;  
  std::vector<CbmTofHit> fhit;    
  Double_t fP[4];                 
 
  CbmTofTracklet&
  operator=(const CbmTofTracklet&); 
  ClassDef(CbmTofTracklet, 3);
};
 
#endif /* CBMTOFTRACKLET_H */