Analysis/VertexFit/include/VertexFit/HTrackParameter.h

Go to the documentation of this file.

#ifndef HTrack_Parameter_H
#define HTrack_Parameter_H
//
//
// Track Parameters in Helix format (drho, phi0, kappa, dz, lambda)
// The helix parameters are used in track fit
// Author: K.L He   date: 04/12/2007, created for Kalman vertex fit
//
//
 
#include "CLHEP/Matrix/Matrix.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Vector/ThreeVector.h"
using CLHEP::Hep3Vector;
using CLHEP::HepLorentzVector;
using CLHEP::HepMatrix;
using CLHEP::HepSymMatrix;
using CLHEP::HepVector;
#include "CLHEP/Geometry/Point3D.h"
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
typedef HepGeom::Point3D<double> HepPoint3D;
#endif
 
class WTrackParameter;
 
class HTrackParameter {
 
public:
  HTrackParameter();
  ~HTrackParameter() { ; }
  HTrackParameter( const HTrackParameter& htrk );
  HTrackParameter& operator=( const HTrackParameter& htrk );
  HTrackParameter( const HepVector helix, const HepSymMatrix eMatrix, const int trackid,
                   const int partid );
  HTrackParameter( const HepVector helix, const double error[], const int trackid,
                   const int partid );
 
  //
  // HTrackParameter from WTrackParameter
  //
  HTrackParameter( const WTrackParameter wtrk );
  //
  // measurement equation and derivative matrices
  //
  HTrackParameter( const int charge, const HepVector p, const HepVector x );
  HepMatrix dHdx( const HepVector p, const HepVector x );
  HepMatrix dHdp( const HepVector p, const HepVector x );
 
  HepVector    hel() const { return m_hel; }
  HepVector    helix() const { return m_hel; }
  HepSymMatrix eHel() const { return m_eHel; }
  int          trackID() const { return m_trackID; }
  int          partID() const { return m_partID; }
 
  // charge
  inline int charge() const;
  // 3-momentum and 3-position
  inline double           pxy() const;
  inline HepVector        p() const;
  inline HepVector        x() const;
  inline Hep3Vector       p3() const;
  inline HepPoint3D       x3() const;
  inline HepLorentzVector p( const double mass ) const;
  HepPoint3D              center() const;
  double                  radius() const;
  // helix parameter
  double drho() const { return m_hel[0]; }
  double phi0() const { return m_hel[1]; }
  double kappa() const { return m_hel[2]; }
  double dz() const { return m_hel[3]; }
  double lambda() const { return m_hel[4]; }
 
  // WTrackParameter
  WTrackParameter wTrack() const;
  WTrackParameter wTrack( const double mass ) const;
 
  // set partID, trackID
  void setTrackID( const int trackID ) { m_trackID = trackID; }
  void setPartID( const int partID ) { m_partID = partID; }
  // set helix parameter and covariance matrix
  void setHel( const HepVector he ) { m_hel = he; }
  void setEHel( const HepSymMatrix eH ) { m_eHel = eH; }
  //
  // some utility function
  //
  // mass
  double xmass( const int i ) const;
  //
  // int section position with helix, plane, cylinder, cone, etc
  //
  HepPoint3D positionTwoHelix( const HTrackParameter ) const; // intersection position in x-y
                                                              // plane
  HepPoint3D positionPlane( const double ) const;
  HepPoint3D positionCylinder( const double ) const;
  HepPoint3D positionCone() const;
  //
  //  Mininum distance between helix and helix, helix and line
  //
  double minDistanceTwoHelix( const HTrackParameter G, HepPoint3D& pos );
 
private:
  int          m_trackID; // for vertex reconstruction
  int          m_partID;  // for Kalman track, 0:e, 1:mu, 2:pi, 3:K, 4:p
  HepVector    m_hel;     // 5 helix parameter
  HepSymMatrix m_eHel;    // 5x5 error matrix
};
 
inline int HTrackParameter::charge() const { return ( m_hel[2] > 0 ? +1 : -1 ); }
 
inline double HTrackParameter::pxy() const { return fabs( 1 / m_hel[2] ); }
 
inline HepVector HTrackParameter::p() const {
  HepVector p0( 3, 0 );
  double    pxy = 1. / fabs( m_hel[2] );
  p0[0]         = 0 - pxy * sin( m_hel[1] );
  p0[1]         = pxy * cos( m_hel[1] );
  p0[2]         = pxy * m_hel[4];
  return p0;
}
 
inline HepVector HTrackParameter::x() const {
  HepVector v0( 3, 0 );
  v0[0] = m_hel[0] * cos( m_hel[1] );
  v0[1] = m_hel[0] * sin( m_hel[1] );
  v0[2] = m_hel[3];
  return v0;
}
 
inline HepPoint3D HTrackParameter::x3() const {
  return HepPoint3D( m_hel[0] * cos( m_hel[1] ), m_hel[0] * sin( m_hel[1] ), m_hel[3] );
}
 
inline Hep3Vector HTrackParameter::p3() const {
  double pxy = 1. / fabs( m_hel[2] );
  return Hep3Vector( 0 - pxy * sin( m_hel[1] ), pxy * cos( m_hel[1] ), pxy * m_hel[4] );
}
 
inline HepLorentzVector HTrackParameter::p( const double mass ) const {
  //   // xum 2007-12-28
  //   //Hep3Vector ptrk = (p3()).rho();
  //   Hep3Vector ptrk = (p3()).r();
  //   double e = sqrt(ptrk*ptrk+mass*mass);
  //   return HepLorentzVector(p3(), e);
 
  // nefedov 2011-11-17
  Hep3Vector p3tmp = p3();
  double     ptrk  = p3tmp.r();
  double     e     = sqrt( ptrk * ptrk + mass * mass );
  return HepLorentzVector( p3tmp, e );
}
 
#endif