---

Helix.h

#ifndef HELIX_CLASS_HELIX
#define HELIX_CLASS_HELIX

#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Geometry/Point3D.h"

class Helix {

public:
  Helix();

  Helix(const Helix &h);

  Helix(const HepPoint3D & pivot,
        const HepVector & a,
        const HepSymMatrix & Ea);
  
  Helix(const HepPoint3D & pivot,
        const HepVector & a);
  
  Helix(const HepPoint3D & position,
        const Hep3Vector & momentum,
        double charge);
  
  virtual ~Helix();
  
public:// Selectors
  const HepPoint3D & center(void) const;
  
  const HepPoint3D & pivot(void) const;
  
  double radius(void) const;
  
  HepPoint3D x(double dPhi = 0.) const;
  double * x(double dPhi, double p[3]) const; // p[3] is the same as the retured values.
  
  HepPoint3D x(double dPhi, HepSymMatrix & Ex) const;
  
  Hep3Vector direction(double dPhi = 0.) const;
  
  Hep3Vector momentum(double dPhi = 0.) const;
  
  Hep3Vector momentum(double dPhi, HepSymMatrix & Em) const;
  
  HepLorentzVector momentum(double dPhi, double mass) const;
  
  HepLorentzVector momentum(double dPhi, double mass, HepSymMatrix & Em) const;
  
  HepLorentzVector momentum(double dPhi, double mass, HepPoint3D & x, HepSymMatrix & Emx) const;  

  double a0(void) const;
  double dr(void) const; // dr is the same as a0.
  double z(void) const;
  double phi(void) const;
  double cotth(void) const;
  double ptinv(void) const;
  double kappa(void) const; // kappa is the same as ptinv.
  // order ATLAS[a0,z,phi,cotth,ptinv]
  //       BELLE[dr,phi0,kappa,dz,tanl]

  double sinPhi(void) const; // sin(phi)
  double cosPhi(void) const; // cos(phi)
  
  const HepVector & a(void) const;
  
  const HepSymMatrix & Ea(void) const;
  
  const HepVector & a(const HepVector & newA); 
  
  const HepSymMatrix & Ea(const HepSymMatrix & newdA);
  
  const HepPoint3D & pivot(const HepPoint3D & newPivot);
  
  void set(const HepPoint3D & pivot,
           const HepVector & a,
           const HepSymMatrix & Ea);
  
  void ignoreErrorMatrix(void);
  
  double bFieldZ(double);
  double bFieldZ(void) const;
  
  Helix & operator = (const Helix &);
  
  // Mathmatical functions
  HepMatrix delApDelA(const HepVector & ap, const HepPoint3D & newPivot) const;
  HepMatrix delXDelA(double phi) const;
  HepMatrix delMDelA(double phi) const;
  HepMatrix del4MDelA(double phi, double mass) const;
  HepMatrix del4MXDelA(double phi, double mass) const;

protected:
  virtual void updateCache(void);
  
private:
  double m_bField; // Tesla
  double m_alpha;
  HepPoint3D m_pivot;
  HepVector m_a;
  HepSymMatrix m_Ea;
  bool m_isValidErrorMatrix;
  
private: // caches
  HepPoint3D m_center;
  double m_cp;
  double m_sp;
  double m_pt;
  double m_r;
  double m_ac[5];
};

inline
const HepPoint3D &
Helix::center(void) const {
  return m_center;
}

inline
const HepPoint3D &
Helix::pivot(void) const {
  return m_pivot;
}

inline
double
Helix::radius(void) const {
  return m_r;
}

inline
Hep3Vector
Helix::direction(double phi) const {
  return momentum(phi).unit();
}

inline
double
Helix::a0(void) const {
  return m_ac[0];
}

inline
double
Helix::dr(void) const {
  return m_ac[0];
}

inline
double
Helix::z(void) const {
  return m_ac[1];
}

inline
double
Helix::phi(void) const {
  return m_ac[2];
}

inline
double
Helix::cotth(void) const {
  return m_ac[3];
}

inline
double
Helix::ptinv(void) const {
  return m_ac[4];
}

inline
double
Helix::kappa(void) const {
  return m_ac[4];
}

inline
const HepVector &
Helix::a(void) const {
  return m_a;
}

inline
const HepSymMatrix &
Helix::Ea(void) const {
  return m_Ea;
}

inline
const HepVector &
Helix::a(const HepVector & i) {
  m_a = i;
  updateCache();
  return m_a;
}

inline
const HepSymMatrix &
Helix::Ea(const HepSymMatrix & i) {
  return m_Ea = i;
}

inline
double
Helix::bFieldZ(void) const {
  return m_bField;
}

inline
double
Helix::sinPhi(void) const {
  return m_sp;
}

inline
double
Helix::cosPhi(void) const {
  return m_cp;
}
#endif // HELIX_CLASS_HELIX

---