StPicoTrack.h

#ifndef StPicoTrack_h
#define StPicoTrack_h

// C++ headers
#include <cmath>

// ROOT headers
#include "TObject.h"
#include "TVector3.h"

// PicoDst headers
#include "StPicoHelix.h"
#include "StPicoPhysicalHelix.h"

#if defined (_VANILLA_ROOT_)
#include "SystemOfUnits.h"
#include "PhysicalConstants.h"
#else
#include "StarClassLibrary/SystemOfUnits.h"
#include "StarClassLibrary/PhysicalConstants.h"
#endif

#if defined (__TFG__VERSION__)
#include "StPicoTrackCovMatrix.h"
#endif /* __TFG__VERSION__ */

//_________________
class StPicoTrack : public TObject {

 public:
  StPicoTrack();
  StPicoTrack(const StPicoTrack &track);
  virtual ~StPicoTrack();
  virtual void Print(const Char_t *option = "") const;

#if defined (__TFG__VERSION__)
  enum { eTopologyMap = 3 };
#else /* !  __TFG__VERSION__ */
  enum { eTopologyMap = 2 };
#endif /* __TFG__VERSION__ */

  //
  // Getters
  //

  Int_t   id() const              { return mId; }
  Float_t chi2() const            { return mChi2 / 1000.f; }
  TVector3 pMom() const           { return TVector3(mPMomentumX, mPMomentumY, mPMomentumZ); }
  TVector3 gMom() const           { return TVector3(mGMomentumX, mGMomentumY, mGMomentumZ); }
  TVector3 origin() const         { return TVector3(mOriginX, mOriginY, mOriginZ); }
  Float_t gPt() const             { return gMom().Perp(); }
  Float_t gPtot() const           { return gMom().Mag(); }
  Float_t pPt() const             { return isPrimary() ? pMom().Perp() : 0.; }
  Float_t pPtot() const           { return isPrimary() ? pMom().Mag() : 0.; }
  TVector3 gMom(TVector3 pVtx, Float_t B) const;
  StPicoPhysicalHelix helix(Float_t const B) const;

  // Next functions return DCA (or its components) of the global track
  // to the point with coordinates (pVtxX, pVtxY, pVtxZ)

  Float_t gDCAx(Float_t pVtxX) const     { return (mOriginX - pVtxX); }
  Float_t gDCAy(Float_t pVtxY) const     { return (mOriginY - pVtxY); }
  Float_t gDCAz(Float_t pVtxZ) const     { return (mOriginZ - pVtxZ); }
  Float_t gDCAxy(Float_t pVtxX, Float_t pVtxY) const;
  Float_t gDCA(Float_t pVtxX, Float_t pVtxY, Float_t pVtxZ) const;
  TVector3 gDCA(TVector3 pVtx) const;
  Float_t gDCAs(TVector3 pVtx) const;
  Short_t charge() const                 { return (mNHitsFit > 0) ? 1 : -1; }
  Int_t   nHits() const                  { return (mNHitsFit > 0) ? (Int_t)mNHitsFit : (Int_t)(-1 * mNHitsFit); }
  Int_t   nHitsFit() const               { return (mNHitsFit > 0) ? (Int_t)mNHitsFit : (Int_t)(-1 * mNHitsFit); }
  Int_t   nHitsMax() const               { return (Int_t)mNHitsMax; }
  Int_t   nHitsPoss() const              { return nHitsMax(); }
  Int_t   nHitsDedx() const              { return (Int_t)mNHitsDedx; }
  UInt_t  hftHitsMap() const             { return topologyMap(0) >> 1 & 0x7F; }
  Float_t dEdx() const                   { return mDedx; }
  Float_t dEdxError() const              { return mDedxError; }

#if defined (__TFG__VERSION__)
  Float_t dEdxPull(Float_t mass, UChar_t fit = 1, Int_t charge = 1) const;
  Float_t dEdxPullToF(Float_t mass, UChar_t fit = 1, Int_t charge = 1) const;
  Float_t dEdxPullPion()      const { return dEdxPull(0.13956995,1); }
  Float_t dEdxPullKaon()      const { return dEdxPull(0.493677,1); }
  Float_t dEdxPullProton()    const { return dEdxPull(0.93827231,1); }
  Float_t dEdxPullElectron()  const { return dEdxPull(0.51099907e-3,1); }
#endif
  Float_t dNdx() const              { return mDnDx; }
  Float_t dNdxError() const         { return mDnDxError; }
  Char_t  status() const            { return mStatus; }

  Float_t nSigmaPion() const             { return (Float_t)mNSigmaPion / 1000.f; }
  Float_t nSigmaKaon() const             { return (Float_t)mNSigmaKaon / 1000.f; }
  Float_t nSigmaProton() const           { return (Float_t)mNSigmaProton / 1000.f; }
  Float_t nSigmaElectron() const         { return (Float_t)mNSigmaElectron / 1000.f; }

  UInt_t  topologyMap(UInt_t idx) const  { return (idx>1) ? 0 : mTopologyMap[idx]; }
#if !defined (__TFG__VERSION__)
  ULong64_t iTpcTopologyMap() const      { return mTopoMap_iTpc; }
#endif
  

  Bool_t hasPxl1Hit() const              { return hftHitsMap() >> 0 & 0x1; }        
  Bool_t hasPxl2Hit() const              { return hftHitsMap() >> 1 & 0x3; }
  Bool_t hasIstHit() const               { return hftHitsMap() >> 3 & 0x3; }
  Bool_t hasSstHit() const               { return hftHitsMap() >> 5 & 0x3; }
  Bool_t isHft() const                   { return hasPxl1Hit() && hasPxl2Hit() && (hasIstHit() || hasSstHit()); }
  Bool_t isHFTTrack() const              { return isHft(); }
  Bool_t hasHft4Layers() const           { return hasPxl1Hit() && hasPxl2Hit() && hasIstHit() && hasSstHit(); }
  Bool_t isTofTrack() const              { return (mBTofPidTraitsIndex<0) ? false : true; }
  Bool_t isBemcTrack() const             { return (mBEmcPidTraitsIndex<0) ? false : true; }
  Bool_t isMtdTrack() const              { return (mMtdPidTraitsIndex<0) ? false : true; }
  Bool_t isETofTrack() const             { return (mETofPidTraitsIndex<0) ? false : true; }
  Bool_t isBemcMatchedTrack() const      { return mBEmcMatchedTowerIndex != 0; }

  Bool_t isPrimary() const               { return ( pMom().Mag()>0 ); }

  Int_t bemcPidTraitsIndex() const       { return mBEmcPidTraitsIndex; }
  Int_t bTofPidTraitsIndex() const       { return mBTofPidTraitsIndex; }
  Int_t mtdPidTraitsIndex() const        { return mMtdPidTraitsIndex; }
  Int_t eTofPidTraitsIndex() const       { return mETofPidTraitsIndex; }

  Int_t bemcTowerIndex() const           { return abs(mBEmcMatchedTowerIndex) - 1; }
  Bool_t isBemcMatchedExact() const      { return mBEmcMatchedTowerIndex > 0;}
  Int_t idTruth() const                  { return mIdTruth; }
  Int_t qaTruth() const                  { return mQATruth; }
  Int_t vertexIndex() const              { return (Int_t)mVertexIndex; }

  //
  // Setters
  //

  void setId(Int_t id)                   { mId = (UShort_t)id; }
  void setChi2(Float_t chi2);
  void setPrimaryMomentum(Double_t px, Double_t py, Double_t pz)
  { mPMomentumX = (Float_t)px; mPMomentumY = (Float_t)py; mPMomentumZ = (Float_t)pz; }
  void setPrimaryMomentum(Float_t px, Float_t py, Float_t pz)
  { mPMomentumX = px; mPMomentumY = py; mPMomentumZ = pz; }
  void setPrimaryMomentum(TVector3 mom)
  { mPMomentumX = (Float_t)mom.X(); mPMomentumY = (Float_t)mom.Y(); mPMomentumZ = (Float_t)mom.Z(); }
  void setGlobalMomentum(Double_t px, Double_t py, Double_t pz)
  { mGMomentumX = (Float_t)px; mGMomentumY = (Float_t)py; mGMomentumZ = (Float_t)pz; }
  void setGlobalMomentum(Float_t px, Float_t py, Float_t pz)
  { mGMomentumX = px; mGMomentumY = py; mGMomentumZ = pz; }
  void setGlobalMomentum(TVector3 mom)
  { mGMomentumX = (Float_t)mom.X(); mGMomentumY = (Float_t)mom.Y(); mGMomentumZ = (Float_t)mom.Z(); }
  void setOrigin(Double_t x, Double_t y, Double_t z)
  { mOriginX = (Float_t)x; mOriginY = (Float_t)y; mOriginZ = (Float_t)z; }
  void setOrigin(Float_t x, Float_t y, Float_t z)
  { mOriginX = x; mOriginY = y; mOriginZ = z; }
  void setOrigin(TVector3 orig)
  { mOriginX = (Float_t)orig.X(); mOriginY = (Float_t)orig.Y(); mOriginZ = (Float_t)orig.Z(); }

  void setDedx(Float_t dEdx);
  void setDedxError(Float_t dEdxError)     { mDedxError = dEdxError; }

  void setDndx(Float_t dNdx)               { mDnDx = dNdx;}
  void setDndxError(Float_t dNdxError)     { mDnDxError = dNdxError; }
  void setStatus(Char_t k = 0)             { mStatus = k; }
  
  void setNHitsFit(Int_t nhits)            { mNHitsFit = (Char_t)nhits; }
  void setNHitsPossible(Int_t nhits);
  void setNHitsMax(Int_t nhits);
  void setNHitsDedx(Int_t nhits);
  void setNSigmaPion(Float_t ns);
  void setNSigmaKaon(Float_t ns);
  void setNSigmaProton(Float_t ns);
  void setNSigmaElectron(Float_t ns);
  void setTopologyMap(Int_t id, UInt_t word);
#if !defined (__TFG__VERSION__)
  void setiTpcTopologyMap(ULong64_t map)   { mTopoMap_iTpc = map; }
#endif

  void setBEmcPidTraitsIndex(Int_t index)  { mBEmcPidTraitsIndex = (Short_t)index; }
  void setBTofPidTraitsIndex(Int_t index)  { mBTofPidTraitsIndex = (Short_t)index; }
  void setMtdPidTraitsIndex(Int_t index)   { mMtdPidTraitsIndex = (Short_t)index; }
  void setETofPidTraitsIndex(Int_t index)  { mETofPidTraitsIndex = (Short_t)index; }
  void setBEmcMatchedTowerIndex(Int_t index) { mBEmcMatchedTowerIndex = (Short_t)index; }
  void setMcTruth(Int_t index, Int_t qa)   { mIdTruth = (UShort_t)index; mQATruth = (UShort_t)qa; }
  void setVertexIndex(Int_t index);

 protected:

  UShort_t mId;
  UShort_t mChi2;
  Float_t mPMomentumX;
  Float_t mPMomentumY;
  Float_t mPMomentumZ;
  Float_t mGMomentumX;
  Float_t mGMomentumY;
  Float_t mGMomentumZ;
  Float_t mOriginX;
  Float_t mOriginY;
  Float_t mOriginZ;
  
  Float16_t  mDedx;
  Float16_t  mDedxError;
  Float_t  mDnDx;
  Float_t  mDnDxError;
  
  Char_t   mNHitsFit;
  UChar_t  mNHitsMax;
  UChar_t  mNHitsDedx;
  Short_t  mNSigmaPion;
  Short_t  mNSigmaKaon;
  Short_t  mNSigmaProton;
  Short_t  mNSigmaElectron;
  UInt_t   mTopologyMap[eTopologyMap];

  Short_t  mBEmcPidTraitsIndex;
  Short_t  mBTofPidTraitsIndex;
  Short_t  mMtdPidTraitsIndex;
  Short_t  mETofPidTraitsIndex;
  Short_t  mBEmcMatchedTowerIndex;

#if !defined (__TFG__VERSION__)
  ULong64_t mTopoMap_iTpc;
#endif

  Char_t mStatus;

  UShort_t mIdTruth;
  UShort_t mQATruth;
  Char_t   mVertexIndex;

#if !defined (__TFG__VERSION__)
  ClassDef(StPicoTrack, 9)
#else
  ClassDef(StPicoTrack, 10)
#endif
};

#endif