Sti/StiKalmanTrack.h

Go to the documentation of this file.

#ifndef StiKalmanTrack_H
#define StiKalmanTrack_H 1

//STD
#include <vector>
using namespace std;
//Sti
#include "Sti/Base/Factory.h"
#include "StiKTNIterator.h"
#include "StiTrack.h"

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

class StiKalmanTrack : public StiTrack 
{
 public:
  
  StiKalmanTrack() :
    firstNode(0),
    lastNode(0),
    mSeedHitCount(0),
    mFlag(0),
    m(-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 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 calculateTrackLength() const;
        double calculateTrackSegmentLength(const StiKalmanTrackNode &p1, const StiKalmanTrackNode &p2) const;
        double getTrackRadLength() const;
        int calculatePointCount() const;
        int calculateMaxPointCount() const;

  double getTpcDedx() const;
  double getSvtDedx() 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;
#ifdef DO_TPCCATRACKER
   StiKalmanTrackNode * getInnerMostTPCHitNode(int qua=0)   const;
#endif /* DO_TPCCATRACKER */
   int                  getNNodes(int qua=0) const;
   int                  releaseHits(double rMin=4,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);   
   
   
   virtual void add(StiTrackNode * node,int direction);

  int initialize(const vector<StiHit*> &);
#ifdef DO_TPCCATRACKER
  int initialize0(const std::vector<StiHit*> &hits, StiNodePars *firstPars = 0, StiNodePars *lastPars = 0, StiNodeErrs *firstErrs = 0, StiNodeErrs *lastErrs = 0);
#endif /* DO_TPCCATRACKER */
  
   StThreeVector<double> getMomentumAtOrigin() const;
   StThreeVector<double> getPoint(int firstLast=0) const;

   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  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

  bool find(int direction=kOutsideIn);
  int  refit();
  int  refitL();
  void reserveHits();
  StiTrackNode *extendToVertex(StiHit* vertex);
#if 0
  bool extendToVertex(StiHit* vertex, const StiDetector*alternate);
#endif
  void setFlag(long v);
  long getFlag() const;

  StiKalmanTrackNode * extrapolateToBeam();
  StiKalmanTrackNode * extrapolateToRadius(double radius);
  int approx(int mode=0);
  
  void reduce();

  StMCTruth getTruth(double rXYMin=0, double rXYMax=1000) const;  
  void print(const char *opt="") const;
  static void setDebug(int m = 0) {_debug = m;}
  static int  debug() {return _debug;}
  StiKalmanTrack &operator=(const StiKalmanTrack &tk);
  int rejectByHitSet()  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);
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)
  int     mVertex;
  long    mFlag;         //A flag to pack w/ topo info
  double  m;             // mass hypothesis

  double  _dca;

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

};

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

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

inline long 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();
  if (mass<0)
    throw runtime_error("StiKalmanTrack::getRapidity() - particle mass unknown");
  double e = ::sqrt(mass*mass+p[0]*p[0]+p[1]*p[1]+p[2]*p[2]);
  if (e<=p[2])
    throw runtime_error("StiKalmanTrack::getRapidity() - Error: e<=pz");
  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. );
  if (tanTheta>0.)
    return -::log(tanTheta);
  else
    throw runtime_error("StiKalmanTrack::getPseudoRapidity() -E- Attempting ::log(non positive number)");
}

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::getTpcDedx() const
{
  return 0.; // to be changed...
}

inline double StiKalmanTrack::getSvtDedx() const
{
  return 0.; // to be changed...
}
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 
{
  if (!firstNode)
                {
                        cout << "StiKTNBidirectionalIterator StiKalmanTrack::begin() -F- firstNode==0"<<endl;
                        throw runtime_error("StiKalmanTrack::begin() - ERROR - firstNode==0");
                }
  return StiKTNBidirectionalIterator::begin(firstNode);
}
inline StiKTNBidirectionalIterator StiKalmanTrack::rbegin() const 
{
  if (!lastNode)
                {
                        cout << "StiKTNBidirectionalIterator StiKalmanTrack::rbegin() -F- lastNode==0"<<endl;
                        throw runtime_error("StiKalmanTrack::rbegin() - ERROR - lastNode==0");
                }
  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

---