This class represents an ideal helix in perigee parameterization including the covariance matrix of the 5 perigee parameters. More...

#include <UncertainHelix.h>

Inheritance diagram for UncertainHelix:

Public Member Functions
	UncertainHelix ()
	Default constuctor initialising all members to zero.

	UncertainHelix (const ROOT::Math::XYZVector &position, const ROOT::Math::XYZVector &momentum, const short int charge, const double bZ, const TMatrixDSym &cartesianCovariance, const double pValue)
	Constructor initializing class with fit result.

	UncertainHelix (const double &d0, const double &phi0, const double &omega, const double &z0, const double &tanLambda, const TMatrixDSym &covariance, const double pValue)
	Constructor initializing class with perigee parameters.

TMatrixDSym	getCartesianCovariance (const double bZ_tesla=1.5) const
	Getter for the position and momentum covariance matrix.

double	getPValue () const
	Getter for Chi2 Probability of the track fit.

const TMatrixDSym &	getCovariance () const
	Getter for covariance matrix of perigee parameters in matrix form.

void	reverse ()
	Reverses the direction of travel of the helix in place.

double	passiveMoveBy (const ROOT::Math::XYZVector &by)
	Moves origin of the coordinate system (passive transformation) by the given vector.

double	passiveMoveBy (const double &byX, const double &byY, const double &byZ)
	Moves origin of the coordinate system (passive transformation) by the given vector.

const HepPoint3D &	center (void) const
	returns position of helix center(z = 0.);

const HepPoint3D &	pivot (void) const
	returns pivot position.

const HepPoint3D &	pivot (const HepPoint3D &newPivot)
	Sets pivot position.

double	radius (void) const
	returns radious of helix.

HepPoint3D	x (double dPhi=0.) const
	returns position after rotating angle dPhi in phi direction.

double *	x (double dPhi, double p[3]) const
	returns position after rotating angle dPhi in phi direction.

HepPoint3D	x (double dPhi, HepSymMatrix &Ex) const
	returns position and convariance matrix(Ex) after rotation.

Hep3Vector	direction (double dPhi=0.) const
	returns direction vector after rotating angle dPhi in phi direction.

Hep3Vector	momentum (double dPhi=0.) const
	returns momentum vector after rotating angle dPhi in phi direction.

Hep3Vector	momentum (double dPhi, HepSymMatrix &Em) const
	returns momentum vector after rotating angle dPhi in phi direction.

HepLorentzVector	momentum (double dPhi, double mass) const
	returns 4momentum vector after rotating angle dPhi in phi direction.

HepLorentzVector	momentum (double dPhi, double mass, HepSymMatrix &Em) const
	returns 4momentum vector after rotating angle dPhi in phi direction.

HepLorentzVector	momentum (double dPhi, double mass, HepPoint3D &x, HepSymMatrix &Emx) const
	returns 4momentum vector after rotating angle dPhi in phi direction.

double	dr (void) const
	Return helix parameter dr.

double	phi0 (void) const
	Return helix parameter phi0.

double	kappa (void) const
	Return helix parameter kappa.

double	dz (void) const
	Return helix parameter dz.

double	tanl (void) const
	Return helix parameter tangent lambda.

double	curv (void) const
	Return curvature of helix.

double	sinPhi0 (void) const
	Return sin phi0.

double	cosPhi0 (void) const
	Return cos phi0.

const HepVector &	a (void) const
	Returns helix parameters.

const HepVector &	a (const HepVector &newA)
	Sets helix parameters.

const HepSymMatrix &	Ea (void) const
	Returns error matrix.

const HepSymMatrix &	Ea (const HepSymMatrix &newdA)
	Sets helix paramters and error matrix.

void	set (const HepPoint3D &pivot, const HepVector &a, const HepSymMatrix &Ea)
	Sets helix pivot position, parameters, and error matrix.

void	ignoreErrorMatrix (void)
	Unsets error matrix.

double	bFieldZ (double bz)
	Sets/returns z componet of the magnetic field.

double	bFieldZ (void) const
	Returns z componet of the magnetic field.

HepMatrix	delApDelA (const HepVector &ap) const
	DAp/DA.

HepMatrix	delXDelA (double phi) const
	DX/DA.

HepMatrix	delMDelA (double phi) const
	DM/DA.

HepMatrix	del4MDelA (double phi, double mass) const
	DM4/DA.

HepMatrix	del4MXDelA (double phi, double mass) const
	DMX4/DA.

Static Public Member Functions
static void	set_limits (const HepVector &a_min, const HepVector &a_max)
	set limit for parameter "a"

static bool	set_exception (bool)
	set exception

static bool	set_print (bool)
	Set print option for debugging.

Static Public Attributes
static const double	ConstantAlpha = 222.376063
	Constant alpha for uniform field.

Private Member Functions
	ClassDef (UncertainHelix, 2)
	represents an ideal helix in perigee parameterization including covariance matrix

void	updateCache (void)
	updateCache

void	checkValid (void)
	Check whether helix parameters is valid or not.

void	debugPrint (void) const
	Print the helix parameters to stdout.

void	debugHelix (void) const
	Debug Helix.

Private Attributes
TMatrixDSym	m_covariance
	5x5 covariance of the perigee parameters.

Double32_t	m_pValue
	Chi2 Probability of the fit.

bool	m_matrixValid
	True: matrix valid, False: matrix not valid.

bool	m_helixValid
	True: helix valid, False: helix not valid.

double	m_bField
	Magnetic field, assuming uniform Bz in the unit of kG.

double	m_alpha
	10000.0/(speed of light)/B.

HepPoint3D	m_pivot
	Pivot.

HepVector	m_a
	Helix parameter.

HepSymMatrix	m_Ea
	Error of the helix parameter.

HepPoint3D	m_center
	Cache of the center position of Helix.

double	m_cp
	Cache of the cos phi0.

double	m_sp
	Cache of the sin phi0.

double	m_pt
	Cache of the pt.

double	m_r
	Cache of the r.

double	m_ac [5]
	Cache of the helix parameter.

Static Private Attributes
static HepVector	ms_amin
	minimum limit of Helix parameter a

static HepVector	ms_amax
	maxiimum limit of Helix parameter a

static bool	ms_check_range
	Check the helix parameter's range.

static bool	ms_print_debug
	Debug option flag.

static bool	ms_throw_exception
	Throw exception flag.

static const std::string	invalidhelix
	String "Invalid Helix".

Detailed Description

This class represents an ideal helix in perigee parameterization including the covariance matrix of the 5 perigee parameters.

The used perigee parameters are:

- the signed distance from the origin to the perigee. The sign is positive (negative), if the angle from the xy perigee position vector to the transverse momentum vector is +pi/2 (-pi/2). has the same sign as getPerigee().Cross(getMomentum()).Z().
$\phi_0$ - the angle in the xy projection between the transverse momentum and the x axis, which is in [-pi, pi]
$\omega$ - the signed curvature of the track where the sign is given by the charge of the particle
- z coordinate of the perigee
$\tan \lambda$ - the slope of the track in the sz plane (dz/ds)

in that exact order.

It may also store a p-value obtained from the fit of the helix.

Definition at line 36 of file UncertainHelix.h.

Constructor & Destructor Documentation

◆ UncertainHelix() [1/3]

UncertainHelix ( )

Default constuctor initialising all members to zero.

Definition at line 17 of file UncertainHelix.cc.

                               :
  Helix(),
  m_covariance(5),
  m_pValue(0)
{
}

◆ UncertainHelix() [2/3]

UncertainHelix	(	const ROOT::Math::XYZVector &	position,
		const ROOT::Math::XYZVector &	momentum,
		const short int	charge,
		const double	bZ,
		const TMatrixDSym &	cartesianCovariance,
		const double	pValue
	)

Constructor initializing class with fit result.

The given position, momentum and their covariance matrix are extrapolated to the perigee assuming a homogeneous magnetic field in the z direction.

Parameters

position	Position of the track at the perigee.
momentum	Momentum of the track at the perigee.
charge	Charge of the particle.
bZ	Magnetic field to be used for the calculation of the curvature;
cartesianCovariance	6x6 Covariance matrix for position and momentum of the track at the perigee.
pValue	p-value of the fit. It is assumed, that the B-field is parallel to the z-Axis.

Definition at line 24 of file UncertainHelix.cc.

                                                    :
  Helix(ROOT::Math::XYZVector(0.0, 0.0, position.Z()), momentum, charge, bZ),
  m_covariance(cartesianCovariance), // Initialize the covariance matrix to the 6x6 covariance and reduce it afterwards
  m_pValue(pValue)
{
  // Maybe push these out of this function:
  // Indices of the cartesian coordinates
  const int iX = 0;
  const int iY = 1;
  const int iZ = 2;
  const int iPx = 3;
  const int iPy = 4;
  const int iPz = 5;
 
  // We initialised the m_covariance to the cartesian covariance and
  // reduce it now to the real 5x5 matrix that should be there.
 
  // 1. Rotate to a system where phi0 = 0
  TMatrixD jacobianRot(6, 6);
  jacobianRot.Zero();
 
  const double px = momentum.X();
  const double py = momentum.Y();
  const double pt = hypot(px, py);
  const double cosPhi0 = px / pt;
  const double sinPhi0 = py / pt;
 
  // Passive rotation matrix by phi0:
  jacobianRot(iX, iX) = cosPhi0;
  jacobianRot(iX, iY) = sinPhi0;
  jacobianRot(iY, iX) = -sinPhi0;
  jacobianRot(iY, iY) = cosPhi0;
  jacobianRot(iZ, iZ) = 1.0;
 
  jacobianRot(iPx, iPx) = cosPhi0;
  jacobianRot(iPx, iPy) = sinPhi0;
  jacobianRot(iPy, iPx) = -sinPhi0;
  jacobianRot(iPy, iPy) = cosPhi0;
  jacobianRot(iPz, iPz) = 1.0;
 
  m_covariance.Similarity(jacobianRot);
 
  // 2. Translate to perigee parameters on the position
  const double pz = momentum.Z();
  const double invPt = 1 / pt;
  const double invPtSquared = invPt * invPt;
  const double alpha = getAlpha(bZ);
 
  TMatrixD jacobianToHelixParameters(5, 6);
  jacobianToHelixParameters.Zero();
 
  jacobianToHelixParameters(iD0, iY) = -1;
  jacobianToHelixParameters(iPhi0, iX) = charge * invPt / alpha;
  jacobianToHelixParameters(iPhi0, iPy) = invPt;
  jacobianToHelixParameters(iOmega, iPx) = -charge * invPtSquared / alpha;
  jacobianToHelixParameters(iTanLambda, iPx) = - pz * invPtSquared;
  jacobianToHelixParameters(iTanLambda, iPz) = invPt;
  jacobianToHelixParameters(iZ0, iX) = - pz * invPt;
  jacobianToHelixParameters(iZ0, iZ) = 1;
  m_covariance.Similarity(jacobianToHelixParameters);
 
  // The covariance m_covariance is now the correct 5x5 covariance matrix.
  assert(m_covariance.GetNrows() == 5);
 
  // 3. Extrapolate to the origin.
  /* const double arcLength2D = */ passiveMoveBy(-position.X(), -position.Y(), 0.0);
}

◆ UncertainHelix() [3/3]

UncertainHelix	(	const double &	d0,
		const double &	phi0,
		const double &	omega,
		const double &	z0,
		const double &	tanLambda,
		const TMatrixDSym &	covariance,
		const double	pValue
	)

Constructor initializing class with perigee parameters.

Parameters

d0	The signed distance from the origin to the perigee. The sign is positive (negative), if the angle from the xy perigee position vector to the transverse momentum vector is +pi/2 (-pi/2). d0 has the same sign as `getPosition().Cross(getMomentum()).Z()`.
phi0	The angle between the transverse momentum and the x axis and in [-pi, pi]
omega	The signed curvature of the track where the sign is given by the charge of the particle
z0	The z coordinate of the perigee.
tanLambda	The slope of the track in the sz plane (dz/ds)
covariance	5x5 Covariance matrix for the five helix parameters. Indices correspond to the order d0, phi0, omega, z0, tanLambda.
pValue	p-value of the Helix fit

Definition at line 98 of file UncertainHelix.cc.

                                                    :
  Helix(d0, phi0, omega, z0, tanLambda),
  m_covariance(covariance),
  m_pValue(pValue)
{
}

Member Function Documentation

◆ a() [1/2]

const HepVector & a ( const HepVector & newA )

inlineinherited

Sets helix parameters.

Definition at line 444 of file Helix.h.

    {
      if (i.num_row() == 5) {
        m_a = i;
        m_helixValid = false;
        updateCache();
#if defined(BELLE_DEBUG)
        DEBUG_HELIX;
      } else {
        {
          std::cout << "Helix::input vector's num_row is not 5" << std::endl;
          DEBUG_PRINT;
          if (ms_throw_exception) throw invalidhelix;
        }
#endif
      }
      return m_a;
    }

◆ a() [2/2]

const HepVector & a ( void ) const

inlineinherited

Returns helix parameters.

Definition at line 428 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_a;
    }

◆ bFieldZ() [1/2]

double bFieldZ ( double bz )

inlineinherited

Sets/returns z componet of the magnetic field.

Parameters

[in] bz z-component of the magnetic field.

Attention: Helix param. alpha is also stored.

Definition at line 473 of file Helix.h.

    {
      DEBUG_HELIX;
      m_bField = a;
      m_alpha = 10000. / 2.99792458 / m_bField;
      updateCache();
      return m_bField;
    }

◆ bFieldZ() [2/2]

double bFieldZ ( void ) const

inlineinherited

Returns z componet of the magnetic field.

Definition at line 484 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_bField;
    }

◆ center()

const HepPoint3D & center ( void ) const

inlineinherited

returns position of helix center(z = 0.);

Definition at line 343 of file Helix.h.

    {
#if defined(BELLE_DEBUG)
      if (!m_helixValid) {
        DEBUG_PRINT;
        if (msthrow_exception) throw invalidhelix;
      }
#endif
      return m_center;
    }

◆ checkValid()

void checkValid ( void )

privateinherited

Check whether helix parameters is valid or not.

Sets m_helixValid.

Definition at line 895 of file Helix.cc.

{
 
  if (!ms_check_range) return;
  const double adr   = fabs(m_a[0]);
  const double acpa   = fabs(m_a[2]);
  if (!(adr >= ms_amin[0] && adr <= ms_amax[0])) {
    m_helixValid = false;
  } else if (!(acpa >= ms_amin[2] && acpa <= ms_amax[2])) {
    m_helixValid = false;
  } else {
    m_helixValid = true;
  }
  if (!m_helixValid) {
    if (m_a[0] != 0.0 || m_a[1] != 0.0 || m_a[2] != 0.0 ||
        m_a[3] != 0.0 || m_a[4] != 0.0) {
      DEBUG_PRINT;
    }
  }
 
}

◆ cosPhi0()

double cosPhi0 ( void ) const

inlineinherited

Return cos phi0.

Definition at line 500 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_cp;
    }

◆ curv()

double curv ( void ) const

inlineinherited

Return curvature of helix.

Definition at line 420 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_r;
    }

◆ debugHelix()

void debugHelix ( void ) const

privateinherited

Debug Helix.

Definition at line 917 of file Helix.cc.

{
  if (!m_helixValid) {
    if (ms_check_range) {DEBUG_PRINT;}
    if (ms_throw_exception) { throw invalidhelix;}
  }
}

◆ debugPrint()

void debugPrint ( void ) const

privateinherited

Print the helix parameters to stdout.

Definition at line 879 of file Helix.cc.

{
 
  const double dr   = m_a[0];
  const double phi0 = m_a[1];
  const double cpa  = m_a[2];
  const double dz   = m_a[3];
  const double tnl  = m_a[4];
  if (ms_print_debug) {
    std::cout << "Helix::dr = " << dr << " phi0 = " << phi0 << " cpa = " << cpa
              << " dz = " << dz << " tnl = " << tnl << std::endl;
    std::cout << "       pivot = " << m_pivot << std::endl;
  }
}

◆ del4MDelA()

HepMatrix del4MDelA	(	double	phi,
		double	mass
	)		const

inherited

DM4/DA.

Definition at line 749 of file Helix.cc.

{
  DEBUG_HELIX;
 
  //
  //   Calculate Jacobian (@4m/@a)
  //   Vector a  is helix parameters and phi is internal parameter.
  //   Vector 4m is 4 momentum.
  //
 
  HepMatrix d4MDA(4, 5, 0);
 
  double phi0 = m_ac[1];
  double cpa  = m_ac[2];
  double tnl  = m_ac[4];
 
  double cosf0phi = cos(phi0 + phi);
  double sinf0phi = sin(phi0 + phi);
 
  double rho;
  if (cpa != 0.)rho = 1. / cpa;
  else rho = (DBL_MAX);
 
  double charge = 1.;
  if (cpa < 0.)charge = -1.;
 
  double E = sqrt(rho * rho * (1. + tnl * tnl) + mass * mass);
 
  d4MDA[0][1] = -fabs(rho) * cosf0phi;
  d4MDA[0][2] = charge * rho * rho * sinf0phi;
 
  d4MDA[1][1] = -fabs(rho) * sinf0phi;
  d4MDA[1][2] = -charge * rho * rho * cosf0phi;
 
  d4MDA[2][2] = -charge * rho * rho * tnl;
  d4MDA[2][4] = fabs(rho);
 
  if (cpa != 0.0 && E != 0.0) {
    d4MDA[3][2] = (-1. - tnl * tnl) / (cpa * cpa * cpa * E);
    d4MDA[3][4] = tnl / (cpa * cpa * E);
  } else {
    d4MDA[3][2] = (DBL_MAX);
    d4MDA[3][4] = (DBL_MAX);
  }
  return d4MDA;
}

◆ del4MXDelA()

HepMatrix del4MXDelA	(	double	phi,
		double	mass
	)		const

inherited

DMX4/DA.

Definition at line 798 of file Helix.cc.

{
  DEBUG_HELIX;
 
  //
  //   Calculate Jacobian (@4mx/@a)
  //   Vector a  is helix parameters and phi is internal parameter.
  //   Vector 4xm is 4 momentum and position.
  //
 
  HepMatrix d4MXDA(7, 5, 0);
 
  const double& dr      = m_ac[0];
  const double& phi0    = m_ac[1];
  const double& cpa     = m_ac[2];
  //const double & dz      = m_ac[3];
  const double& tnl     = m_ac[4];
 
  double cosf0phi = cos(phi0 + phi);
  double sinf0phi = sin(phi0 + phi);
 
  double rho;
  if (cpa != 0.)rho = 1. / cpa;
  else rho = (DBL_MAX);
 
  double charge = 1.;
  if (cpa < 0.)charge = -1.;
 
  double E = sqrt(rho * rho * (1. + tnl * tnl) + mass * mass);
 
  d4MXDA[0][1] = - fabs(rho) * cosf0phi;
  d4MXDA[0][2] = charge * rho * rho * sinf0phi;
 
  d4MXDA[1][1] = - fabs(rho) * sinf0phi;
  d4MXDA[1][2] = - charge * rho * rho * cosf0phi;
 
  d4MXDA[2][2] = - charge * rho * rho * tnl;
  d4MXDA[2][4] = fabs(rho);
 
  if (cpa != 0.0 && E != 0.0) {
    d4MXDA[3][2] = (- 1. - tnl * tnl) / (cpa * cpa * cpa * E);
    d4MXDA[3][4] = tnl / (cpa * cpa * E);
  } else {
    d4MXDA[3][2] = (DBL_MAX);
    d4MXDA[3][4] = (DBL_MAX);
  }
 
  d4MXDA[4][0] = m_cp;
  d4MXDA[4][1] = - dr * m_sp + m_r * (- m_sp + sinf0phi);
  if (cpa != 0.0) {
    d4MXDA[4][2] = - (m_r / cpa) * (m_cp - cosf0phi);
  } else {
    d4MXDA[4][2] = (DBL_MAX);
  }
 
  d4MXDA[5][0] = m_sp;
  d4MXDA[5][1] = dr * m_cp + m_r * (m_cp - cosf0phi);
  if (cpa != 0.0) {
    d4MXDA[5][2] = - (m_r / cpa) * (m_sp - sinf0phi);
 
    d4MXDA[6][2] = (m_r / cpa) * tnl * phi;
  } else {
    d4MXDA[5][2] = (DBL_MAX);
 
    d4MXDA[6][2] = (DBL_MAX);
  }
 
  d4MXDA[6][3] = 1.;
  d4MXDA[6][4] = - m_r * phi;
 
  return d4MXDA;
}

◆ delApDelA()

HepMatrix delApDelA ( const HepVector & ap ) const

inherited

DAp/DA.

Definition at line 584 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  //   Calculate Jacobian (@ap/@a)
  //   Vector ap is new helix parameters and a is old helix parameters.
  //
 
  HepMatrix dApDA(5, 5, 0);
 
  const double& dr    = m_ac[0];
  const double& phi0  = m_ac[1];
  const double& cpa   = m_ac[2];
  //const double & dz    = m_ac[3];
  const double& tnl   = m_ac[4];
 
  double drp   = ap[0];
  double phi0p = ap[1];
  //double cpap  = ap[2];
  //double dzp   = ap[3];
  //double tnlp  = ap[4];
 
  double rdr   = m_r + dr;
  double rdrpr;
  if ((m_r + drp) != 0.0) {
    rdrpr = 1. / (m_r + drp);
  } else {
    rdrpr = (DBL_MAX);
  }
  // double csfd  = cos(phi0)*cos(phi0p) + sin(phi0)*sin(phi0p);
  // double snfd  = cos(phi0)*sin(phi0p) - sin(phi0)*cos(phi0p);
  double csfd  = cos(phi0p - phi0);
  double snfd  = sin(phi0p - phi0);
  double phid  = fmod(phi0p - phi0 + M_PI8, M_PI2);
  if (phid > M_PI) phid = phid - M_PI2;
 
  dApDA[0][0]  =  csfd;
  dApDA[0][1]  =  rdr * snfd;
  if (cpa != 0.0) {
    dApDA[0][2]  = (m_r / cpa) * (1.0 - csfd);
  } else {
    dApDA[0][2]  = (DBL_MAX);
  }
 
  dApDA[1][0]  = - rdrpr * snfd;
  dApDA[1][1]  = rdr * rdrpr * csfd;
  if (cpa != 0.0) {
    dApDA[1][2]  = (m_r / cpa) * rdrpr * snfd;
  } else {
    dApDA[1][2]  = (DBL_MAX);
  }
 
  dApDA[2][2]  = 1.0;
 
  dApDA[3][0]  = m_r * rdrpr * tnl * snfd;
  dApDA[3][1]  = m_r * tnl * (1.0 - rdr * rdrpr * csfd);
  if (cpa != 0.0) {
    dApDA[3][2]  = (m_r / cpa) * tnl * (phid - m_r * rdrpr * snfd);
  } else {
    dApDA[3][2]  = (DBL_MAX);
  }
  dApDA[3][3]  = 1.0;
  dApDA[3][4]  = - m_r * phid;
 
  dApDA[4][4] = 1.0;
 
  return dApDA;
}

◆ delMDelA()

HepMatrix delMDelA ( double phi ) const

inherited

DM/DA.

Definition at line 710 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  //   Calculate Jacobian (@m/@a)
  //   Vector a is helix parameters and phi is internal parameter.
  //   Vector m is momentum.
  //
 
  HepMatrix dMDA(3, 5, 0);
 
  const double& phi0 = m_ac[1];
  const double& cpa  = m_ac[2];
  const double& tnl  = m_ac[4];
 
  double cosf0phi = cos(phi0 + phi);
  double sinf0phi = sin(phi0 + phi);
 
  double rho;
  if (cpa != 0.)rho = 1. / cpa;
  else rho = (DBL_MAX);
 
  double charge = 1.;
  if (cpa < 0.)charge = -1.;
 
  dMDA[0][1] = -fabs(rho) * cosf0phi;
  dMDA[0][2] = charge * rho * rho * sinf0phi;
 
  dMDA[1][1] = -fabs(rho) * sinf0phi;
  dMDA[1][2] = -charge * rho * rho * cosf0phi;
 
  dMDA[2][2] = -charge * rho * rho * tnl;
  dMDA[2][4] = fabs(rho);
 
  return dMDA;
}

◆ delXDelA()

HepMatrix delXDelA ( double phi ) const

inherited

DX/DA.

Definition at line 654 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  //   Calculate Jacobian (@x/@a)
  //   Vector a is helix parameters and phi is internal parameter
  //   which specifys the point to be calculated for Ex(phi).
  //
 
  HepMatrix dXDA(3, 5, 0);
 
  const double& dr      = m_ac[0];
  const double& phi0    = m_ac[1];
  const double& cpa     = m_ac[2];
  //const double & dz      = m_ac[3];
  const double& tnl     = m_ac[4];
 
  double cosf0phi = cos(phi0 + phi);
  double sinf0phi = sin(phi0 + phi);
 
  dXDA[0][0]     = m_cp;
  dXDA[0][1]     = - dr * m_sp + m_r * (- m_sp + sinf0phi);
  if (cpa != 0.0) {
    dXDA[0][2]     = - (m_r / cpa) * (m_cp - cosf0phi);
  } else {
    dXDA[0][2] = (DBL_MAX);
  }
  // dXDA[0][3]     = 0.0;
  // dXDA[0][4]     = 0.0;
 
  dXDA[1][0]     = m_sp;
  dXDA[1][1]     = dr * m_cp + m_r * (m_cp - cosf0phi);
  if (cpa != 0.0) {
    dXDA[1][2]     = - (m_r / cpa) * (m_sp - sinf0phi);
  } else {
    dXDA[1][2] = (DBL_MAX);
  }
  // dXDA[1][3]     = 0.0;
  // dXDA[1][4]     = 0.0;
 
  // dXDA[2][0]     = 0.0;
  // dXDA[2][1]     = 0.0;
  if (cpa != 0.0) {
    dXDA[2][2]     = (m_r / cpa) * tnl * phi;
  } else {
    dXDA[2][2] = (DBL_MAX);
  }
  dXDA[2][3]     = 1.0;
  dXDA[2][4]     = - m_r * phi;
 
  return dXDA;
}

◆ direction()

Hep3Vector direction ( double dPhi = 0. ) const

inlineinherited

returns direction vector after rotating angle dPhi in phi direction.

Definition at line 372 of file Helix.h.

    {
      DEBUG_HELIX;
      return momentum(phi).unit();
    }

◆ dr()

double dr ( void ) const

inlineinherited

Return helix parameter dr.

Definition at line 380 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_ac[0];
    }

◆ dz()

double dz ( void ) const

inlineinherited

Return helix parameter dz.

Definition at line 404 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_ac[3];
    }

◆ Ea() [1/2]

const HepSymMatrix & Ea ( const HepSymMatrix & newdA )

inlineinherited

Sets helix paramters and error matrix.

Definition at line 465 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_Ea = i;
    }

◆ Ea() [2/2]

const HepSymMatrix & Ea ( void ) const

inlineinherited

Returns error matrix.

Definition at line 436 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_Ea;
    }

◆ getCartesianCovariance()

TMatrixDSym getCartesianCovariance ( const double bZ_tesla = 1.5 ) const

Getter for the position and momentum covariance matrix.

Note: Because the position and momentum covariance matrix is regenerated from a 5x5 perigee parameter covariance matrix there is necessarily a missing rank in the resulting matrix. The rank has to be filled by a convention essentially expressing, which points around the perigee are considered to be at s = 0. For backwards compatability with the original Belle experiment we apply the convention used there. See the Belle II note for more details.

Parameters

bZ_tesla Magnetic field to be used for the calculation from the curvature;

Rotate to the right phi0

Definition at line 113 of file UncertainHelix.cc.

{
  // 0. Define indices
  // Maybe push these out of this function:
  // Indices of the cartesian coordinates
  const int iX = 0;
  const int iY = 1;
  const int iZ = 2;
  const int iPx = 3;
  const int iPy = 4;
  const int iPz = 5;
 
  // Transform covariance matrix
  TMatrixD jacobianInflate(6, 5);
  jacobianInflate.Zero();
 
  // 1. Inflate the perigee covariance to a cartesian covariance where phi0 == 0 is assumed
  // The real phi0 is a simple rotation which can be handled in the next step.
  // Jacobian matrix for the translation
 
  const double& d0 = getD0();
  const double& omega = getOmega();
  const double& tanLambda = getTanLambda();
 
  const double alpha = getAlpha(bZ_tesla);
  const double absAlphaOmega = alpha * std::fabs(omega);
  const double signedAlphaOmega2 = absAlphaOmega * omega;
 
  const double invAbsAlphaOmega = 1.0 / absAlphaOmega;
  const double invSignedAlphaOmega2 = 1.0 / signedAlphaOmega2;
 
  // Position after the move.
  jacobianInflate(iX, iPhi0) = d0;
  jacobianInflate(iY, iD0) = -1.0;
  jacobianInflate(iZ, iZ0) = 1.0;
 
  // Momentum
  jacobianInflate(iPx, iOmega) = -invSignedAlphaOmega2;
  jacobianInflate(iPy, iPhi0) = invAbsAlphaOmega;
  jacobianInflate(iPz, iOmega) = -tanLambda * invSignedAlphaOmega2;
  jacobianInflate(iPz, iTanLambda) = invAbsAlphaOmega;
 
  TMatrixDSym cov6 = m_covariance; //copy
  cov6.Similarity(jacobianInflate);
 
  const double& cosPhi0 = getCosPhi0();
  const double& sinPhi0 = getSinPhi0();
 
  TMatrixD jacobianRot(6, 6);
  jacobianRot.Zero();
 
  // Active rotation matrix by phi0:
  jacobianRot(iX, iX) = cosPhi0;
  jacobianRot(iX, iY) = -sinPhi0;
  jacobianRot(iY, iX) = sinPhi0;
  jacobianRot(iY, iY) = cosPhi0;
  jacobianRot(iZ, iZ) = 1.0;
 
  jacobianRot(iPx, iPx) = cosPhi0;
  jacobianRot(iPx, iPy) = -sinPhi0;
  jacobianRot(iPy, iPx) = sinPhi0;
  jacobianRot(iPy, iPy) = cosPhi0;
  jacobianRot(iPz, iPz) = 1.0;
 
  cov6.Similarity(jacobianRot);
  return cov6;
}

◆ getCovariance()

const TMatrixDSym & getCovariance ( ) const

inline

Getter for covariance matrix of perigee parameters in matrix form.

Definition at line 100 of file UncertainHelix.h.

101 { return m_covariance; }

◆ getPValue()

double getPValue ( ) const

inline

Getter for Chi2 Probability of the track fit.

Definition at line 94 of file UncertainHelix.h.

95 { return m_pValue; }

◆ ignoreErrorMatrix()

void ignoreErrorMatrix ( void )

inherited

Unsets error matrix.

Error calculations will be ignored after this function call until an error matrix be set again. 0 matrix will be return as a return value for error matrix when you call functions which returns an error matrix.

Definition at line 872 of file Helix.cc.

{
  m_matrixValid = false;
  m_Ea *= 0.;
}

◆ kappa()

double kappa ( void ) const

inlineinherited

Return helix parameter kappa.

Definition at line 396 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_ac[2];
    }

◆ momentum() [1/5]

HepLorentzVector momentum	(	double	dPhi,
		double	mass
	)		const

inherited

returns 4momentum vector after rotating angle dPhi in phi direction.

Definition at line 306 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  // Calculate momentum.
  //
  // Pt = | 1/kappa | (GeV/c)
  //
  // Px = -Pt * sin(phi0 + phi)
  // Py =  Pt * cos(phi0 + phi)
  // Pz =  Pt * tan(lambda)
  //
  // E  = sqrt( 1/kappa/kappa * (1+tan(lambda)*tan(lambda)) + mass*mass )
 
  double pt = fabs(m_pt);
  double px = - pt * sin(m_ac[1] + phi);
  double py =   pt * cos(m_ac[1] + phi);
  double pz =   pt * m_ac[4];
  double E  =   sqrt(pt * pt * (1. + m_ac[4] * m_ac[4]) + mass * mass);
 
  return HepLorentzVector(px, py, pz, E);
}

◆ momentum() [2/5]

HepLorentzVector momentum	(	double	dPhi,
		double	mass,
		HepPoint3D &	x,
		HepSymMatrix &	Emx
	)		const

inherited

returns 4momentum vector after rotating angle dPhi in phi direction.

Definition at line 358 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  // Calculate momentum.
  //
  // Pt = | 1/kappa | (GeV/c)
  //
  // Px = -Pt * sin(phi0 + phi)
  // Py =  Pt * cos(phi0 + phi)
  // Pz =  Pt * tan(lambda)
  //
  // E  = sqrt( 1/kappa/kappa * (1+tan(lambda)*tan(lambda)) + mass*mass )
 
  double pt = fabs(m_pt);
  double px = - pt * sin(m_ac[1] + phi);
  double py =   pt * cos(m_ac[1] + phi);
  double pz =   pt * m_ac[4];
  double E  = sqrt(pt * pt * (1. + m_ac[4] * m_ac[4]) + mass * mass);
 
  x.setX(m_pivot.x() + m_ac[0] * m_cp + m_r * (m_cp - cos(m_ac[1] + phi)));
  x.setY(m_pivot.y() + m_ac[0] * m_sp + m_r * (m_sp - sin(m_ac[1] + phi)));
  x.setZ(m_pivot.z() + m_ac[3] - m_r * m_ac[4] * phi);
 
  if (m_matrixValid) Emx = m_Ea.similarity(del4MXDelA(phi, mass));
  else               Emx = m_Ea;
 
  return HepLorentzVector(px, py, pz, E);
}

◆ momentum() [3/5]

HepLorentzVector momentum	(	double	dPhi,
		double	mass,
		HepSymMatrix &	Em
	)		const

inherited

returns 4momentum vector after rotating angle dPhi in phi direction.

Definition at line 331 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  // Calculate momentum.
  //
  // Pt = | 1/kappa | (GeV/c)
  //
  // Px = -Pt * sin(phi0 + phi)
  // Py =  Pt * cos(phi0 + phi)
  // Pz =  Pt * tan(lambda)
  //
  // E  = sqrt( 1/kappa/kappa * (1+tan(lambda)*tan(lambda)) + mass*mass )
 
  double pt = fabs(m_pt);
  double px = - pt * sin(m_ac[1] + phi);
  double py =   pt * cos(m_ac[1] + phi);
  double pz =   pt * m_ac[4];
  double E  =   sqrt(pt * pt * (1. + m_ac[4] * m_ac[4]) + mass * mass);
 
  if (m_matrixValid) Em = m_Ea.similarity(del4MDelA(phi, mass));
  else               Em = m_Ea;
 
  return HepLorentzVector(px, py, pz, E);
}

◆ momentum() [4/5]

Hep3Vector momentum	(	double	dPhi,
		HepSymMatrix &	Em
	)		const

inherited

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 281 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  // Calculate momentum.
  //
  // Pt = | 1/kappa | (GeV/c)
  //
  // Px = -Pt * sin(phi0 + phi)
  // Py =  Pt * cos(phi0 + phi)
  // Pz =  Pt * tan(lambda)
  //
 
  double pt = fabs(m_pt);
  double px = - pt * sin(m_ac[1] + phi);
  double py =   pt * cos(m_ac[1] + phi);
  double pz =   pt * m_ac[4];
 
  if (m_matrixValid) Em = m_Ea.similarity(delMDelA(phi));
  else               Em = m_Ea;
 
  return Hep3Vector(px, py, pz);
}

◆ momentum() [5/5]

Hep3Vector momentum ( double dPhi = 0. ) const

inherited

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 259 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  // Calculate momentum.
  //
  // Pt = | 1/kappa | (GeV/c)
  //
  // Px = -Pt * sin(phi0 + phi)
  // Py =  Pt * cos(phi0 + phi)
  // Pz =  Pt * tan(lambda)
  //
 
  double pt = fabs(m_pt);
  double px = - pt * sin(m_ac[1] + phi);
  double py =   pt * cos(m_ac[1] + phi);
  double pz =   pt * m_ac[4];
 
  return Hep3Vector(px, py, pz);
}

◆ passiveMoveBy() [1/2]

double passiveMoveBy	(	const double &	byX,
		const double &	byY,
		const double &	byZ
	)

Moves origin of the coordinate system (passive transformation) by the given vector.

Updates the helix inplace.

Parameters

byX	X displacement by which the origin of the coordinate system should be moved.
byY	Y displacement by which the origin of the coordinate system should be moved.
byZ	Z displacement by which the origin of the coordinate system should be moved.

Returns: The double value is the two dimensional arc length, which has the be traversed from the old perigee to the new.

Definition at line 198 of file UncertainHelix.cc.

{
  // Move the covariance matrix first to have access to the original parameters
  TMatrixD jacobianPassiveMove(5, 5);
  calcPassiveMoveByJacobian(byX, byY, jacobianPassiveMove);
  m_covariance.Similarity(jacobianPassiveMove);
  return Helix::passiveMoveBy(byX, byY, byZ);
}

◆ passiveMoveBy() [2/2]

double passiveMoveBy ( const ROOT::Math::XYZVector & by )

inline

Moves origin of the coordinate system (passive transformation) by the given vector.

Updates the helix inplace.

Parameters

by	Vector by which the origin of the coordinate system should be moved.

Returns: The double value is the two dimensional arc length, which has the be traversed from the old perigee to the new.

Definition at line 117 of file UncertainHelix.h.

118 { return passiveMoveBy(by.X(), by.Y(), by.Z()); }

◆ phi0()

double phi0 ( void ) const

inlineinherited

Return helix parameter phi0.

Definition at line 388 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_ac[1];
    }

◆ pivot() [1/2]

const HepPoint3D & pivot ( const HepPoint3D & newPivot )

inherited

Sets pivot position.

Definition at line 393 of file Helix.cc.

{
  DEBUG_HELIX;
#if defined(BELLE_DEBUG)
  try {
#endif
    const double& dr    = m_ac[0];
    const double& phi0  = m_ac[1];
    const double& kappa = m_ac[2];
    const double& dz    = m_ac[3];
    const double& tanl  = m_ac[4];
 
    double rdr = dr + m_r;
    double phi = fmod(phi0 + M_PI4, M_PI2);
    double csf0 = cos(phi);
    double snf0 = (1. - csf0) * (1. + csf0);
    snf0 = sqrt((snf0 > 0.) ? snf0 : 0.);
    if (phi > M_PI) snf0 = - snf0;
 
    double xc = m_pivot.x() + rdr * csf0;
    double yc = m_pivot.y() + rdr * snf0;
    double csf, snf;
    if (m_r != 0.0) {
      csf = (xc - newPivot.x()) / m_r;
      snf = (yc - newPivot.y()) / m_r;
      double anrm = sqrt(csf * csf + snf * snf);
      if (anrm != 0.0) {
        csf /= anrm;
        snf /= anrm;
        phi = atan2(snf, csf);
      } else {
        csf = 1.0;
        snf = 0.0;
        phi = 0.0;
      }
    } else {
      csf = 1.0;
      snf = 0.0;
      phi = 0.0;
    }
    double phid = fmod(phi - phi0 + M_PI8, M_PI2);
    if (phid > M_PI) phid = phid - M_PI2;
    double drp = (m_pivot.x() + dr * csf0 + m_r * (csf0 - csf) - newPivot.x())
                 * csf
                 + (m_pivot.y() + dr * snf0 + m_r * (snf0 - snf) - newPivot.y()) * snf;
    double dzp = m_pivot.z() + dz - m_r * tanl * phid - newPivot.z();
 
    HepVector ap(5);
    ap[0] = drp;
    ap[1] = fmod(phi + M_PI4, M_PI2);
    ap[2] = kappa;
    ap[3] = dzp;
    ap[4] = tanl;
 
    //    if (m_matrixValid) m_Ea.assign(delApDelA(ap) * m_Ea * delApDelA(ap).T());
    if (m_matrixValid) m_Ea = m_Ea.similarity(delApDelA(ap));
 
    m_a = ap;
    m_pivot = newPivot;
 
    //...Are these needed?...iw...
    updateCache();
    return m_pivot;
#if defined(BELLE_DEBUG)
  } catch (...) {
    m_helixValid = false;
    DEBUG_PRINT;
    if (ms_throw_exception) throw invalidhelix;
  }
#endif
  return m_pivot;
}

◆ pivot() [2/2]

const HepPoint3D & pivot ( void ) const

inlineinherited

returns pivot position.

Definition at line 356 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_pivot;
    }

◆ radius()

double radius ( void ) const

inlineinherited

returns radious of helix.

Definition at line 364 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_r;
    }

◆ reverse()

void reverse ( )

Reverses the direction of travel of the helix in place.

The same points that are located on the helix stay are the same after the transformation, but have the opposite two dimensional arc length associated to them. The momentum at each point is reversed. The charge sign is changed to its opposite by this transformation.

Definition at line 182 of file UncertainHelix.cc.

{
  Helix::reverse();
 
  // D0, omega and tan lambda have to be taken to their opposites
  // Phi0 is augmented by pi which does not change its covariances
  // Z0 stays the same
  TMatrixD jacobianReverse(5, 5);
  jacobianReverse.UnitMatrix();
  jacobianReverse(iD0, iD0) = -1;
  jacobianReverse(iOmega, iOmega) = -1;
  jacobianReverse(iTanLambda, iTanLambda) = -1;
 
  m_covariance.Similarity(jacobianReverse);
}

◆ set()

void set	(	const HepPoint3D &	pivot,
		const HepVector &	a,
		const HepSymMatrix &	Ea
	)

inherited

Sets helix pivot position, parameters, and error matrix.

Definition at line 467 of file Helix.cc.

{
  m_pivot = pivot;
  m_a = a;
  m_Ea = Ea;
  m_matrixValid = true;
  m_helixValid = false;
  updateCache();
  DEBUG_HELIX;
}

◆ set_exception()

bool set_exception ( bool t )

staticinherited

set exception

Definition at line 112 of file Helix.cc.

{
  return ms_throw_exception = t;
}

◆ set_limits()

void set_limits	(	const HepVector &	a_min,
		const HepVector &	a_max
	)

staticinherited

set limit for parameter "a"

Definition at line 123 of file Helix.cc.

{
  if (a_min.num_row() != 5 || a_max.num_row() != 5) return;
  ms_amin = a_min;
  ms_amax = a_max;
  ms_check_range = true;
}

◆ set_print()

bool set_print ( bool t )

staticinherited

Set print option for debugging.

Definition at line 117 of file Helix.cc.

{
  return ms_print_debug = t;
}

◆ sinPhi0()

double sinPhi0 ( void ) const

inlineinherited

Return sin phi0.

Definition at line 492 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_sp;
    }

◆ tanl()

double tanl ( void ) const

inlineinherited

Return helix parameter tangent lambda.

Definition at line 412 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_ac[4];
    }

◆ updateCache()

void updateCache ( void )

privateinherited

updateCache

Definition at line 508 of file Helix.cc.

{
 
#if defined(BELLE_DEBUG)
  checkValid();
  if (m_helixValid) {
#endif
 
    //
    //   Calculate Helix center( xc, yc ).
    //
    //   xc = x0 + (dr + (alpha / kappa)) * cos(phi0)  (cm)
    //   yc = y0 + (dr + (alpha / kappa)) * sin(phi0)  (cm)
    //
 
    m_ac[0] = m_a[0];
    m_ac[1] = m_a[1];
    m_ac[2] = m_a[2];
    m_ac[3] = m_a[3];
    m_ac[4] = m_a[4];
 
    m_cp = cos(m_ac[1]);
    m_sp = sin(m_ac[1]);
    if (m_ac[2] != 0.0) {
      if (m_ac[2] == DBL_MAX || m_ac[2] == (-DBL_MAX)) {
        m_pt = m_r = 0;
        return;
      } else {
        m_pt = 1. / m_ac[2];
        m_r = m_alpha / m_ac[2];
      }
    } else {
      m_pt = (DBL_MAX);
      m_r = (DBL_MAX);
      return;
    }
 
    double x = m_pivot.x() + (m_ac[0] + m_r) * m_cp;
    double y = m_pivot.y() + (m_ac[0] + m_r) * m_sp;
    m_center.setX(x);
    m_center.setY(y);
    m_center.setZ(0.);
#if defined(BELLE_DEBUG)
  } else {
    m_ac[0] = m_a[0];
    m_ac[1] = m_a[1];
    m_ac[2] = m_a[2];
    m_ac[3] = m_a[3];
    m_ac[4] = m_a[4];
 
    m_cp = cos(m_ac[1]);
    m_sp = sin(m_ac[1]);
    if (m_ac[2] != 0.0) {
      if (m_ac[2] == DBL_MAX || m_ac[2] == (-DBL_MAX)) {
        m_pt = m_r = 0;
        return;
      } else {
        m_pt = 1. / m_ac[2];
        m_r = m_alpha / m_ac[2];
      }
    } else {
      m_pt = (DBL_MAX);
      m_r = (DBL_MAX);
      return;
    }
 
    double x = m_pivot.x() + (m_ac[0] + m_r) * m_cp;
    double y = m_pivot.y() + (m_ac[0] + m_r) * m_sp;
    m_center.setX(x);
    m_center.setY(y);
    m_center.setZ(0.);
  }
#endif
}

◆ x() [1/3]

double * x	(	double	dPhi,
		double	p[3]
	)		const

inherited

returns position after rotating angle dPhi in phi direction.

x = x0 + dr * cos(phi0) + (alpha / kappa) * (cos(phi0) - cos(phi0+phi)) y = y0 + dr * sin(phi0) + (alpha / kappa) * (sin(phi0) - sin(phi0+phi)) z = z0 + dz - (alpha / kappa) * tan(lambda) * phi

Returns: double[3]

Definition at line 216 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  // Calculate position (x,y,z) along helix.
  //
  // x = x0 + dr * cos(phi0) + (alpha / kappa) * (cos(phi0) - cos(phi0+phi))
  // y = y0 + dr * sin(phi0) + (alpha / kappa) * (sin(phi0) - sin(phi0+phi))
  // z = z0 + dz             - (alpha / kappa) * tan(lambda) * phi
  //
 
  p[0] = m_pivot.x() + m_ac[0] * m_cp + m_r * (m_cp - cos(m_ac[1] + phi));
  p[1] = m_pivot.y() + m_ac[0] * m_sp + m_r * (m_sp - sin(m_ac[1] + phi));
  p[2] = m_pivot.z() + m_ac[3] - m_r * m_ac[4] * phi;
 
  return p;
}

◆ x() [2/3]

HepPoint3D x	(	double	dPhi,
		HepSymMatrix &	Ex
	)		const

inherited

returns position and convariance matrix(Ex) after rotation.

Definition at line 235 of file Helix.cc.

{
  DEBUG_HELIX;
 
  double x = m_pivot.x() + m_ac[0] * m_cp + m_r * (m_cp - cos(m_ac[1] + phi));
  double y = m_pivot.y() + m_ac[0] * m_sp + m_r * (m_sp - sin(m_ac[1] + phi));
  double z = m_pivot.z() + m_ac[3] - m_r * m_ac[4] * phi;
 
  //
  //   Calculate position error matrix.
  //   Ex(phi) = (@x/@a)(Ea)(@x/@a)^T, phi is deflection angle to specify the
  //   point to be calcualted.
  //
  // HepMatrix dXDA(3, 5, 0);
  // dXDA = delXDelA(phi);
  // Ex.assign(dXDA * m_Ea * dXDA.T());
 
  if (m_matrixValid) Ex = m_Ea.similarity(delXDelA(phi));
  else               Ex = m_Ea;
 
  return HepPoint3D(x, y, z);
}

◆ x() [3/3]

HepPoint3D x ( double dPhi = 0. ) const

inherited

returns position after rotating angle dPhi in phi direction.

x = x0 + dr * cos(phi0) + (alpha / kappa) * (cos(phi0) - cos(phi0+phi)) y = y0 + dr * sin(phi0) + (alpha / kappa) * (sin(phi0) - sin(phi0+phi)) z = z0 + dz - (alpha / kappa) * tan(lambda) * phi

Returns: HepPoint3D

Definition at line 197 of file Helix.cc.

{
  DEBUG_HELIX;
  //
  // Calculate position (x,y,z) along helix.
  //
  // x = x0 + dr * cos(phi0) + (alpha / kappa) * (cos(phi0) - cos(phi0+phi))
  // y = y0 + dr * sin(phi0) + (alpha / kappa) * (sin(phi0) - sin(phi0+phi))
  // z = z0 + dz             - (alpha / kappa) * tan(lambda) * phi
  //
 
  double x = m_pivot.x() + m_ac[0] * m_cp + m_r * (m_cp - cos(m_ac[1] + phi));
  double y = m_pivot.y() + m_ac[0] * m_sp + m_r * (m_sp - sin(m_ac[1] + phi));
  double z = m_pivot.z() + m_ac[3] - m_r * m_ac[4] * phi;
 
  return HepPoint3D(x, y, z);
}

Member Data Documentation

◆ ConstantAlpha

const double ConstantAlpha = 222.376063

staticinherited

Constant alpha for uniform field.

Definition at line 283 of file Helix.h.

◆ invalidhelix

const std::string invalidhelix

staticprivateinherited

String "Invalid Helix".

Definition at line 318 of file Helix.h.

◆ m_a

HepVector m_a

privateinherited

Helix parameter.

Definition at line 298 of file Helix.h.

◆ m_ac

double m_ac[5]

privateinherited

Cache of the helix parameter.

Definition at line 315 of file Helix.h.

◆ m_alpha

double m_alpha

privateinherited

10000.0/(speed of light)/B.

Definition at line 294 of file Helix.h.

◆ m_bField

double m_bField

privateinherited

Magnetic field, assuming uniform Bz in the unit of kG.

Definition at line 292 of file Helix.h.

◆ m_center

HepPoint3D m_center

privateinherited

Cache of the center position of Helix.

Definition at line 305 of file Helix.h.

◆ m_covariance

TMatrixDSym m_covariance

private

5x5 covariance of the perigee parameters.

Definition at line 134 of file UncertainHelix.h.

◆ m_cp

double m_cp

privateinherited

Cache of the cos phi0.

Definition at line 307 of file Helix.h.

◆ m_Ea

HepSymMatrix m_Ea

privateinherited

Error of the helix parameter.

Definition at line 300 of file Helix.h.

◆ m_helixValid

bool m_helixValid

privateinherited

True: helix valid, False: helix not valid.

Definition at line 290 of file Helix.h.

◆ m_matrixValid

bool m_matrixValid

privateinherited

True: matrix valid, False: matrix not valid.

Definition at line 288 of file Helix.h.

◆ m_pivot

HepPoint3D m_pivot

privateinherited

Pivot.

Definition at line 296 of file Helix.h.

◆ m_pt

double m_pt

privateinherited

Cache of the pt.

Definition at line 311 of file Helix.h.

◆ m_pValue

Double32_t m_pValue

private

Chi2 Probability of the fit.

Definition at line 137 of file UncertainHelix.h.

◆ m_r

double m_r

privateinherited

Cache of the r.

Definition at line 313 of file Helix.h.

◆ m_sp

double m_sp

privateinherited

Cache of the sin phi0.

Definition at line 309 of file Helix.h.

◆ ms_amax

HepVector ms_amax

staticprivateinherited

maxiimum limit of Helix parameter a

Definition at line 233 of file Helix.h.

◆ ms_amin

HepVector ms_amin

staticprivateinherited

minimum limit of Helix parameter a

Definition at line 231 of file Helix.h.

◆ ms_check_range

bool ms_check_range

staticprivateinherited

Check the helix parameter's range.

Definition at line 235 of file Helix.h.

◆ ms_print_debug

bool ms_print_debug

staticprivateinherited

Debug option flag.

Definition at line 237 of file Helix.h.

◆ ms_throw_exception

bool ms_throw_exception

staticprivateinherited

Throw exception flag.

Definition at line 239 of file Helix.h.

The documentation for this class was generated from the following files:

framework/dataobjects/include/UncertainHelix.h
framework/dataobjects/src/UncertainHelix.cc

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ UncertainHelix() [1/3]

◆ UncertainHelix() [2/3]

◆ UncertainHelix() [3/3]

Member Function Documentation

◆ a() [1/2]

◆ a() [2/2]

◆ bFieldZ() [1/2]

◆ bFieldZ() [2/2]

◆ center()

◆ checkValid()

◆ cosPhi0()

◆ curv()

◆ debugHelix()

◆ debugPrint()

◆ del4MDelA()

◆ del4MXDelA()

◆ delApDelA()

◆ delMDelA()

◆ delXDelA()

◆ direction()

◆ dr()

◆ dz()

◆ Ea() [1/2]

◆ Ea() [2/2]

◆ getCartesianCovariance()

◆ getCovariance()

◆ getPValue()

◆ ignoreErrorMatrix()

◆ kappa()

◆ momentum() [1/5]

◆ momentum() [2/5]

◆ momentum() [3/5]

◆ momentum() [4/5]

◆ momentum() [5/5]

◆ passiveMoveBy() [1/2]

◆ passiveMoveBy() [2/2]

◆ phi0()

◆ pivot() [1/2]

◆ pivot() [2/2]

◆ radius()

◆ reverse()

◆ set()

◆ set_exception()

◆ set_limits()

◆ set_print()

◆ sinPhi0()

◆ tanl()

◆ updateCache()

◆ x() [1/3]

◆ x() [2/3]

◆ x() [3/3]

Member Data Documentation

◆ ConstantAlpha

◆ invalidhelix

◆ m_a

◆ m_ac

◆ m_alpha

◆ m_bField

◆ m_center

◆ m_covariance

◆ m_cp

◆ m_Ea

◆ m_helixValid

◆ m_matrixValid

◆ m_pivot

◆ m_pt

◆ m_pValue

◆ m_r

◆ m_sp

◆ ms_amax

◆ ms_amin

◆ ms_check_range