Helix Class Reference

Helix parameter class. More...

#include <Helix.h>

Inheritance diagram for Helix:

Public Member Functions
	Helix (const HepPoint3D &pivot, const HepVector &a, const HepSymMatrix &Ea)
	Constructor with pivot, helix parameter a, and its error matrix.
	Helix (const HepPoint3D &pivot, const HepVector &a)
	Constructor without error matrix.
	Helix (const HepPoint3D &position, const Hep3Vector &momentum, double charge)
	Constructor with position, momentum, and charge.
virtual	~Helix ()
	Destructor.
const HepPoint3D &	center (void) const
	returns position of helix center(z = 0.);
const HepPoint3D &	pivot (void) const
	returns 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 HepSymMatrix &	Ea (void) const
	Returns error matrix.
const HepVector &	a (const HepVector &newA)
	Sets helix parameters.
const HepSymMatrix &	Ea (const HepSymMatrix &newdA)
	Sets helix parameters and error matrix.
const HepPoint3D &	pivot (const HepPoint3D &newPivot)
	Sets pivot position.
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 component of the magnetic field.
double	bFieldZ (void) const
	Returns z component of the magnetic field.
Helix &	operator= (const Helix &)
	Copy operator.
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
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
bool	m_matrixValid = false
	True: matrix valid, False: matrix not valid.
bool	m_helixValid = false
	True: helix valid, False: helix not valid.
double	m_bField = 15.0
	Magnetic field, assuming uniform Bz in the unit of kG.
double	m_alpha = 222.376063
	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] = {0.0, 0.0, 0.0, 0.0, 0.0}
	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

Helix parameter class.

Definition at line 48 of file Helix.h.

Constructor & Destructor Documentation

Helix() [1/3]

Helix	(	const HepPoint3D &	pivot,
		const HepVector &	a,
		const HepSymMatrix &	Ea )

Constructor with pivot, helix parameter a, and its error matrix.

Definition at line 136 of file Helix.cc.

  : m_matrixValid(true),
    m_helixValid(false),
    m_bField(15.0),
    m_alpha(222.376063),
    m_pivot(pivot),
    m_a(a),
    m_Ea(Ea)
{
  // m_alpha = 10000. / 2.99792458 / m_bField;
  // m_alpha = 222.376063;
  if (m_a.num_row() == 5 && m_Ea.num_row() == 5) {
    updateCache();
  }
}

Helix() [2/3]

Helix	(	const HepPoint3D &	pivot,
		const HepVector &	a )

Constructor without error matrix.

Definition at line 154 of file Helix.cc.

  : m_matrixValid(false),
    m_helixValid(false),
    m_bField(15.0),
    m_alpha(222.376063),
    m_pivot(pivot),
    m_a(a),
    m_Ea(HepSymMatrix(5, 0))
{
  // m_alpha = 222.376063;
  if (m_a.num_row() == 5) {
    updateCache();
  }
}

Helix() [3/3]

Helix	(	const HepPoint3D &	position,
		const Hep3Vector &	momentum,
		double	charge )

Constructor with position, momentum, and charge.

Definition at line 170 of file Helix.cc.

  : m_matrixValid(false),
    m_helixValid(false),
    m_bField(15.0),
    m_alpha(222.376063),
    m_pivot(position),
    m_a(HepVector(5, 0)),
    m_Ea(HepSymMatrix(5, 0))
{
  m_a[0] = 0.;
  m_a[3] = 0.;
  double perp(momentum.perp());
  if (perp != 0.0) {
    m_a[1] = fmod(atan2(- momentum.x(), momentum.y())
                  + M_PI4, M_PI2);
    m_a[2] = charge / perp;
    m_a[4] = momentum.z() / perp;
  } else {
    m_a[2] = charge * (DBL_MAX);
  }
  // m_alpha = 222.376063;
  updateCache();
}

~Helix()

~Helix ( )

virtual

Destructor.

Definition at line 196 of file Helix.cc.

{
}

Member Function Documentation

a() [1/2]

const HepVector & a ( const HepVector & newA )

inline

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

inline

Returns helix parameters.

Definition at line 428 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_a;
    }

bFieldZ() [1/2]

double bFieldZ ( double bz )

inline

Sets/returns z component 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

inline

Returns z component of the magnetic field.

Definition at line 484 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_bField;
    }

center()

const HepPoint3D & center ( void ) const

inline

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 )

private

Check whether helix parameters is valid or not.

Sets m_helixValid.

Definition at line 902 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

inline

Return cos phi0.

Definition at line 500 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_cp;
    }

curv()

double curv ( void ) const

inline

Return curvature of helix.

Definition at line 420 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_r;
    }

debugHelix()

void debugHelix ( void ) const

private

Debug Helix.

Definition at line 925 of file Helix.cc.

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

debugPrint()

void debugPrint ( void ) const

private

Print the helix parameters to stdout.

Definition at line 885 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

DM4/DA.

Definition at line 754 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

DMX4/DA.

Definition at line 803 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

DAp/DA.

Definition at line 589 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

DM/DA.

Definition at line 715 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

DX/DA.

Definition at line 659 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

inline

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

inline

Return helix parameter dr.

Definition at line 380 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_ac[0];
    }

dz()

double dz ( void ) const

inline

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 )

inline

Sets helix parameters 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

inline

Returns error matrix.

Definition at line 436 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_Ea;
    }

ignoreErrorMatrix()

void ignoreErrorMatrix

(

void

)

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 877 of file Helix.cc.

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

kappa()

double kappa ( void ) const

inline

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

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

Definition at line 310 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

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

Definition at line 362 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

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

Definition at line 335 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

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 285 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

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 263 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);
}

operator=()

Helix & operator=

(

const Helix &

i

)

Copy operator.

Definition at line 486 of file Helix.cc.

{
  if (this == & i) return * this;
  DEBUG_HELIX;
 
  m_bField = i.m_bField;
  m_alpha = i.m_alpha;
  m_pivot = i.m_pivot;
  m_a = i.m_a;
  m_Ea = i.m_Ea;
  m_matrixValid = i.m_matrixValid;
 
  m_center = i.m_center;
  m_cp = i.m_cp;
  m_sp = i.m_sp;
  m_pt = i.m_pt;
  m_r  = i.m_r;
  m_ac[0] = i.m_ac[0];
  m_ac[1] = i.m_ac[1];
  m_ac[2] = i.m_ac[2];
  m_ac[3] = i.m_ac[3];
  m_ac[4] = i.m_ac[4];
 
  return * this;
}

phi0()

double phi0 ( void ) const

inline

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

)

Sets pivot position.

Definition at line 397 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

inline

returns pivot position.

Definition at line 356 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_pivot;
    }

radius()

double radius ( void ) const

inline

returns radious of helix.

Definition at line 364 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_r;
    }

set()

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

Sets helix pivot position, parameters, and error matrix.

Definition at line 471 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 )

static

set exception

Definition at line 116 of file Helix.cc.

{
  return ms_throw_exception = t;
}

set_limits()

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

static

set limit for parameter "a"

Definition at line 127 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 )

static

Set print option for debugging.

Definition at line 121 of file Helix.cc.

{
  return ms_print_debug = t;
}

sinPhi0()

double sinPhi0 ( void ) const

inline

Return sin phi0.

Definition at line 492 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_sp;
    }

tanl()

double tanl ( void ) const

inline

Return helix parameter tangent lambda.

Definition at line 412 of file Helix.h.

    {
      DEBUG_HELIX;
      return m_ac[4];
    }

updateCache()

void updateCache ( void )

private

updateCache

Definition at line 513 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

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

returns position and convariance matrix(Ex) after rotation.

Definition at line 239 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 calculated.
  //
  // 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

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

static

Constant alpha for uniform field.

Definition at line 283 of file Helix.h.

invalidhelix

const std::string invalidhelix

staticprivate

String "Invalid Helix".

Definition at line 318 of file Helix.h.

m_a

HepVector m_a

private

Helix parameter.

Definition at line 298 of file Helix.h.

m_ac

double m_ac[5] = {0.0, 0.0, 0.0, 0.0, 0.0}

private

Cache of the helix parameter.

Definition at line 315 of file Helix.h.

{0.0, 0.0, 0.0, 0.0, 0.0};

m_alpha

double m_alpha = 222.376063

private

10000.0/(speed of light)/B.

Definition at line 294 of file Helix.h.

m_bField

double m_bField = 15.0

private

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

Definition at line 292 of file Helix.h.

m_center

HepPoint3D m_center

private

Cache of the center position of Helix.

Definition at line 305 of file Helix.h.

m_cp

double m_cp

private

Cache of the cos phi0.

Definition at line 307 of file Helix.h.

m_Ea

HepSymMatrix m_Ea

private

Error of the helix parameter.

Definition at line 300 of file Helix.h.

m_helixValid

bool m_helixValid = false

private

True: helix valid, False: helix not valid.

Definition at line 290 of file Helix.h.

m_matrixValid

bool m_matrixValid = false

private

True: matrix valid, False: matrix not valid.

Definition at line 288 of file Helix.h.

m_pivot

HepPoint3D m_pivot

private

Pivot.

Definition at line 296 of file Helix.h.

m_pt

double m_pt

private

Cache of the pt.

Definition at line 311 of file Helix.h.

m_r

double m_r

private

Cache of the r.

Definition at line 313 of file Helix.h.

m_sp

double m_sp

private

Cache of the sin phi0.

Definition at line 309 of file Helix.h.

ms_amax

HepVector ms_amax

staticprivate

maxiimum limit of Helix parameter a

Definition at line 233 of file Helix.h.

ms_amin

HepVector ms_amin

staticprivate

minimum limit of Helix parameter a

Definition at line 231 of file Helix.h.

ms_check_range

bool ms_check_range

staticprivate

Check the helix parameter's range.

Definition at line 235 of file Helix.h.

ms_print_debug

bool ms_print_debug

staticprivate

Debug option flag.

Definition at line 237 of file Helix.h.

ms_throw_exception

bool ms_throw_exception

staticprivate

Throw exception flag.

Definition at line 239 of file Helix.h.

---

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

• cdc/simulation/include/Helix.h
• cdc/simulation/src/Helix.cc