StiKalmanTrack.h

Go to the documentation of this file.

#ifndef StiKalmanTrack_H
#define StiKalmanTrack_H 1

#include <cassert>
//STD
#include <vector>
//Sti
#include "Sti/Base/Factory.h"
#include "Sti/StiKTNIterator.h"
#include "Sti/StiTrack.h"
#include "Sti/StiTrackNodeHelper.h"

#include "StThreeVectorD.hh"
#include "StMCTruth.h"
class StiHit;
class StiTrackNode;
class StiKalmanTrackNode;

enum nodeQA {kKeepHit=1,kGoodHit=2};


class StiKalmanTrack : public StiTrack 
{
 public:

  enum { kAppGud =1, kAppRR=2, kAppUpd = 4, kAppUPD = 8 };
  
  StiKalmanTrack() :
    firstNode(0),
    lastNode(0),
    mSeedHitCount(0),
    mFlag(0),
    mMass(-1.)
    {  /* nops */ }
  
  virtual ~StiKalmanTrack()
    {  }
  
  static void setKalmanTrackNodeFactory(Factory<StiKalmanTrackNode>*);
  static void setMaxRefiter(int maxRefiter);

  void reset();
  void unset();
  
  void    getMomentum(double p[3], double e[6]) const ;
  
  double  getP() const;
  
  double  getPt() const;
  
  double  getCurvature() const; 
  
  double  getRapidity() const;
  
  double  getPseudoRapidity() const;
  
  double  getPhi()            const;
  
        double  getTanL()           const;

   double  getDca()    const;
   virtual double  getDca(const StiHit * vertex)    const;

   void setDca(double dca);
   
   double getDca(StiTrack *t)   const;

   int     combUsed() const     {return mCombUsed  ;}
   void setCombUsed(int comb)   {mCombUsed = comb&7;}
  
   int getPointCount(int detectorId=0) const;

   int getFitPointCount(int detectorId=0) const;  

   void getAllPointCount(int count[1][3],int maxDetId) const;
   
   int getGapCount() const;

   double getTrackLength() const;
   double getNearBeam(StThreeVectorD *pnt=0,StThreeVectorD *dir=0) const;
  
   int getMaxPointCount(int detectorId=0) const;

   UShort_t getSeedHitCount() const {return mSeedHitCount;}
   void   setSeedHitCount(UShort_t c) {mSeedHitCount=c;}

   int isPrimary() const        {return mVertex;}
   void setPrimary(int vertex)  {mVertex=vertex;}

        double getTrackRadLength() const;

        StiKTNBidirectionalIterator  begin()  const;
  const StiKTNBidirectionalIterator& end()    const;
        StiKTNBidirectionalIterator  rbegin() const;
  const StiKTNBidirectionalIterator& rend()   const;
  void  removeLastNode();  

   StiKalmanTrackNode * getInnOutMostNode(int inot,int qua)  const;
   StiKalmanTrackNode * getOuterMostNode(int qua=0)  const;
   StiKalmanTrackNode * getInnerMostNode(int qua=0)   const;

   StiKalmanTrackNode * getOuterMostHitNode(int qua=0)  const;
   StiKalmanTrackNode * getInnerMostHitNode(int qua=0)   const;
   StiKalmanTrackNode * getInnerMostDetHitNode(int detectorId)   const;
   int                  getNNodes(int qua=0) const;
   int                  releaseHits(double rMin=0,double rMax=50);
   StiKalmanTrackNode * getFirstNode()  const { return firstNode; };
   // Assumes the track has been pruned.
   StiKalmanTrackNode * getLastNode()   const { return  lastNode; };
   void  setLastNode (StiKalmanTrackNode *n) { lastNode  = n; };
   void  setFirstNode(StiKalmanTrackNode *n) { firstNode = n; };   
   void  setFirstLastNode(StiKalmanTrackNode *n);   
   void  removeNode(StiKalmanTrackNode *n){ n->remove((StiTreeNode**)&firstNode,(StiTreeNode**)&lastNode);}   
   
   
   virtual void add(StiTrackNode * node,int direction,StiTrackNode *near=0);

  virtual int initialize (const vector<StiHit*> &);
  virtual int initialize0(const std::vector<StiHit*> &hits, StiNodePars *firstPars=0, StiNodePars *lastPars=0, StiNodeErrs *firstErrs=0, StiNodeErrs *lastErrs=0);
    
  virtual vector<StiHit*> getHits();
  virtual vector<const StMeasuredPoint*> stHits() const;
  virtual vector<StiKalmanTrackNode*> getNodes(int detectorGroupId) const;
         

  double  getMass()  const;     // mass when pid known
  int     getCharge()const;     // charge of the particle
  double  getChi2()  const;     // chi2/ndf of fit 
  double  getChi2Max() const;   // maximal chi2 
  double  getXi2  () const { return mXi2;}   // helix chi2 
  double  getDca2(StiTrack *t) const;   // distance of closest approach to given track - 2D calc
  double  getDca3(StiTrack *t) const;   // distance of closest approach to given track - 3D calc

  int  refit();
  int  refitL();
  void reserveHits(int yes=1);
  StiTrackNode *extendToVertex(StiHit* vertex);
  void setFlag(int v);
  int  getFlag() const;

  StiKalmanTrackNode * extrapolateToBeam();
  StiKalmanTrackNode * extrapolateToRadius(double radius);
  int approx(int mode = (kAppRR | kAppUPD));
  
  void reduce();

  void print(const char *opt="") const;
  static void setDebug(int d = 0) {_debug = d;}
  static int  debug() {return _debug;}
  StiKalmanTrack &operator=(const StiKalmanTrack &tk);
  int rejectByHitSet()  const;
  int idTruth(int *qu=0) const;

 void test(const char *txt="")  const;
  
  typedef enum{ // type of return value for the refit() procedure
    kNoErrors = 0,
    kRefitFail,
    kNotEnoughUsed,
    kInNodeNotValid,
    kBadQA,
    kVertexNodeInvalid,
    kNodeNotValid,
    kTooManyDroppedNodes
  } TRefitStatus;

  
protected:
  friend ostream& operator<<(ostream& os, const StiKalmanTrack& track);

  // hidden static variables for refit & refiL
  static StiTrackNodeHelper sTNH;
  static double diff(const StiNodePars &p1,const StiNodeErrs &e1
                    ,const StiNodePars &p2,const StiNodeErrs &e2,int &igor);
  // end of hidden static variables for refit & refiL

protected:
    
  static int mgMaxRefiter;              //max number of refit iteratins allowed
  static Factory<StiKalmanTrackNode> * trackNodeFactory;
  
  StiKalmanTrackNode * firstNode;
  StiKalmanTrackNode * lastNode;

  UShort_t  mSeedHitCount; //number of points used to seed the track (seed quality)
  char      mCombUsed;    // save which combinatoric style was used
  int     mVertex;
  int     mFlag;         //A flag to pack w/ topo info
  double  mMass;         // mass hypothesis
  double  mXi2;
  double  _dca;

 public:
  double _vChi2;//
  static int _debug; // Debug level

};

inline double  StiKalmanTrack::getMass() const
{ 
  return mMass;  
}

inline void StiKalmanTrack::setFlag(int v) 
{
  mFlag = v;
}

inline int StiKalmanTrack::getFlag() const 
{
  return mFlag;
}

inline void StiKalmanTrack::getMomentum(double p[3], double e[6]) const
{
  // return the momentum of the track at the inner most node held by this track
  // which may (or not) be the primary vertex. 
  // this will need to be refined...
  getInnerMostHitNode()->getMomentum(p,e);
}

inline double  StiKalmanTrack::getP() const
{
  return getInnerMostHitNode()->getP();
}

inline double  StiKalmanTrack::getPt() const
{
  return getInnerMostHitNode()->getPt();
}

inline double StiKalmanTrack::getCurvature() const
{
  return getInnerMostHitNode()->getCurvature();
}

inline double  StiKalmanTrack::getRapidity()       const 
{
  // returns the rapidity of the particle at the inner most node held by this track
  // which may (or not) be the primary vertex. 
  double p[3];
  StiKalmanTrackNode *  inner = getInnerMostHitNode();
  inner->getMomentum(p,0);
  double mass = getMass();
  assert(mass >= 0);
  double e = ::sqrt(mass*mass+p[0]*p[0]+p[1]*p[1]+p[2]*p[2]);
  assert(e > p[2]);
  return 0.5*::log(e+p[2]/e-p[2]);
}

inline double  StiKalmanTrack::getPseudoRapidity() const
{
  // Return pseudo rapidity of the particle at the inner most node held by this track
  // which may (or not) be the primary vertex. 
  double tanTheta = tan(M_PI/4.- getInnerMostHitNode()->getDipAngle()/2. );
  assert(tanTheta>0.);
  return -::log(tanTheta);
}

inline double  StiKalmanTrack::getPhi()            const 
{
  double p[3];
  getInnerMostHitNode()->getGlobalMomentum(p,0);
  return atan2(p[1],p[0]);
}

inline double  StiKalmanTrack::getTanL()           const 
{
  return getInnerMostHitNode()->getTanL();
}

inline double  StiKalmanTrack::getDca()    const
{
  return _dca;
}

inline void  StiKalmanTrack::setDca(double dca)  
{
  _dca = dca;
}


inline double  StiKalmanTrack::getDca(StiTrack *t)   const
{
  return 0;
}

inline double  StiKalmanTrack::getDca2(StiTrack *t)   const
{
    return 0;
}

inline double  StiKalmanTrack::getDca3(StiTrack *t)   const
{
    return 0;
}


inline StiKTNBidirectionalIterator StiKalmanTrack::begin() const 
{
  assert(firstNode);
  return StiKTNBidirectionalIterator::begin(firstNode);
}
inline StiKTNBidirectionalIterator StiKalmanTrack::rbegin() const 
{
  assert(lastNode);
  return StiKTNBidirectionalIterator::rbegin(lastNode);
}

inline const StiKTNBidirectionalIterator &StiKalmanTrack::end() const 
{
  return StiKTNBidirectionalIterator::end();
}
inline const StiKTNBidirectionalIterator &StiKalmanTrack::rend() const 
{
  return StiKTNBidirectionalIterator::rend();
}

inline StiKalmanTrackNode * StiKalmanTrack::getOuterMostNode(int qua)  const 
{
  return getInnOutMostNode(1,qua);
}

inline StiKalmanTrackNode * StiKalmanTrack::getInnerMostNode(int qua)   const 
{ 
  return getInnOutMostNode(0,qua);
}

#endif