Helix.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
//-----------------------------------------------------------------------------
// Description : A class to represent a track helix parameter in Belle style
//-----------------------------------------------------------------------------
 
#ifndef TRGCDCHelix_FLAG_
#define TRGCDCHelix_FLAG_
 
#include <string>
#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"
 
#ifdef TRGCDC_SHORT_NAMES
#define TCHelix TRGCDCHelix
#endif
 
namespace Belle2 {
  class TRGCDCHelix {
 
  public:
    TRGCDCHelix(const HepGeom::Point3D<double>&   pivot,
                const CLHEP::HepVector& a,
                const CLHEP::HepSymMatrix& Ea);
 
    TRGCDCHelix(const HepGeom::Point3D<double>&   pivot,
                const CLHEP::HepVector& a);
 
    TRGCDCHelix(const HepGeom::Point3D<double>&   position,
                const CLHEP::Hep3Vector& momentum,
                double charge);
 
    TRGCDCHelix(const TRGCDCHelix&) = default;
 
    virtual ~TRGCDCHelix();
 
  public:// Selectors
 
    const HepGeom::Point3D<double>&   center(void) const;
 
    const HepGeom::Point3D<double>&   pivot(void) const;
 
    double radius(void) const;
 
    HepGeom::Point3D<double>  x(double dPhi = 0.) const;
 
    double* x(double dPhi, double p[3]) const;
 
    HepGeom::Point3D<double>  x(double dPhi, CLHEP::HepSymMatrix& Ex) const;
 
    CLHEP::Hep3Vector direction(double dPhi = 0.) const;
 
    CLHEP::Hep3Vector momentum(double dPhi = 0.) const;
 
    CLHEP::Hep3Vector momentum(double dPhi, CLHEP::HepSymMatrix& Em) const;
 
    CLHEP::HepLorentzVector momentum(double dPhi, double mass) const;
 
    CLHEP::HepLorentzVector momentum(double dPhi, double mass, CLHEP::HepSymMatrix& Em) const;
 
    CLHEP::HepLorentzVector momentum(double dPhi, double mass, HepGeom::Point3D<double>&   x, CLHEP::HepSymMatrix& Emx) const;
 
  public:// Parametrization dependent functions. Prepared for tracking codes. Users should not use them.
 
    double dr(void) const;
 
    double phi0(void) const;
 
    double kappa(void) const;
 
    double dz(void) const;
 
    double tanl(void) const;
 
    double curv(void) const;
 
    double sinPhi0(void) const;
 
    double cosPhi0(void) const;
 
    const CLHEP::HepVector& a(void) const;
 
    const CLHEP::HepSymMatrix& Ea(void) const;
 
  public:// Modifiers
    const CLHEP::HepVector& a(const CLHEP::HepVector& newA);
 
    const CLHEP::HepSymMatrix& Ea(const CLHEP::HepSymMatrix& newdA);
 
    const HepGeom::Point3D<double>&   pivot(const HepGeom::Point3D<double>&   newPivot);
 
    void set(const HepGeom::Point3D<double>&   pivot,
             const CLHEP::HepVector& a,
             const CLHEP::HepSymMatrix& Ea);
 
    void ignoreErrorMatrix(void);
 
    double bFieldZ(void) const;
 
    double bFieldZ(double);
 
    static void set_limits(const CLHEP::HepVector& a_min,
                           const CLHEP::HepVector& a_max);
 
    static bool set_exception(bool);
 
    static bool set_print(bool);
 
  private:
    static CLHEP::HepVector ms_amin;
    static CLHEP::HepVector ms_amax;
    static bool ms_check_range;
    static bool ms_print_debug;
    static bool ms_throw_exception;
 
 
  public:// Operators
    TRGCDCHelix& operator = (const TRGCDCHelix&);
 
  public:// Mathmatical functions
    CLHEP::HepMatrix delApDelA(const CLHEP::HepVector& ap) const;
    CLHEP::HepMatrix delXDelA(double phi) const;
    CLHEP::HepMatrix delMDelA(double phi) const;
    CLHEP::HepMatrix del4MDelA(double phi, double mass) const;
    CLHEP::HepMatrix del4MXDelA(double phi, double mass) const;
 
  private:
    void updateCache(void);
    void checkValid(void);
    void debugPrint(void) const;
    void debugTRGCDCHelix(void) const;
 
  public:
    static const double ConstantAlpha;
 
  private:
    bool m_matrixValid;
    bool m_helixValid;
    double m_bField;
    double m_alpha;
    HepGeom::Point3D<double>  m_pivot;
    CLHEP::HepVector m_a;
    CLHEP::HepSymMatrix m_Ea;
 
  private: // caches
    HepGeom::Point3D<double>  m_center;
    double m_cp;
    double m_sp;
    double m_pt;
    double m_r;
    double m_ac[5];
 
    static const std::string invalidhelix;
 
  };
 
//-----------------------------------------------------------------------------
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCHelix::center(void) const
  {
    return m_center;
  }
 
  inline
  const HepGeom::Point3D<double>&
  TRGCDCHelix::pivot(void) const
  {
    return m_pivot;
  }
 
  inline
  double
  TRGCDCHelix::radius(void) const
  {
    return m_r;
  }
 
  inline
  CLHEP::Hep3Vector
  TRGCDCHelix::direction(double phi) const
  {
    return momentum(phi).unit();
  }
 
  inline
  double
  TRGCDCHelix::dr(void) const
  {
    return m_ac[0];
  }
 
  inline
  double
  TRGCDCHelix::phi0(void) const
  {
    return m_ac[1];
  }
 
  inline
  double
  TRGCDCHelix::kappa(void) const
  {
    return m_ac[2];
  }
 
  inline
  double
  TRGCDCHelix::dz(void) const
  {
    return m_ac[3];
  }
 
  inline
  double
  TRGCDCHelix::tanl(void) const
  {
    return m_ac[4];
  }
 
  inline
  double
  TRGCDCHelix::curv(void) const
  {
    return m_r;
  }
 
  inline
  const CLHEP::HepVector&
  TRGCDCHelix::a(void) const
  {
    return m_a;
  }
 
  inline
  const CLHEP::HepSymMatrix&
  TRGCDCHelix::Ea(void) const
  {
    return m_Ea;
  }
 
  inline
  const CLHEP::HepVector&
  TRGCDCHelix::a(const CLHEP::HepVector& i)
  {
    if (i.num_row() == 5) {
      m_a = i;
      m_helixValid = false;
      updateCache();
    }
    return m_a;
  }
 
  inline
  const CLHEP::HepSymMatrix&
  TRGCDCHelix::Ea(const CLHEP::HepSymMatrix& i)
  {
    return m_Ea = i;
  }
 
  inline
  double
  TRGCDCHelix::bFieldZ(double a)
  {
    m_bField = a;
    m_alpha = 10000. / 2.99792458 / m_bField;
    updateCache();
    return m_bField;
  }
 
  inline
  double
  TRGCDCHelix::bFieldZ(void) const
  {
    return m_bField;
  }
 
  inline
  double
  TRGCDCHelix::sinPhi0(void) const
  {
    return m_sp;
  }
 
  inline
  double
  TRGCDCHelix::cosPhi0(void) const
  {
    return m_cp;
  }
 
} // namespace Belle2
 
#endif /* TRGCDCHelix_FLAG_ */