VFHelix Class Reference

VFHelix parameter class. More...

#include <Helix.h>

Public Member Functions
	VFHelix (const HepPoint3D &pivot, const HepVector &a, const HepSymMatrix &Ea)
	Constructor with pivot, helix parameter a, and its error matrix.
	VFHelix (const HepPoint3D &pivot, const HepVector &a)
	Constructor without error matrix.
	VFHelix (const HepPoint3D &position, const Hep3Vector &momentum, double charge)
	Constructor with position, momentum, and charge.
virtual	~VFHelix ()
	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
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
	returns an element of parameters.
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 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 paramters 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. 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.
double	bFieldZ (double)
	sets/returns z componet of the magnetic field.
double	bFieldZ (void) const
VFHelix &	operator= (const VFHelix &)
	Copy operator.
HepMatrix	delApDelA (const HepVector &ap) 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

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

Detailed Description

VFHelix parameter class.

Definition at line 38 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

Constructor & Destructor Documentation

VFHelix() [1/3]

VFHelix::VFHelix	(	const HepPoint3D &	pivot,
		const HepVector &	a,
		const HepSymMatrix &	Ea )

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

Definition at line 37 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

: m_bField(10.0),
  m_alpha(333.564095),
  m_pivot(pivot),
  m_a(a),
  m_Ea(Ea),
  m_matrixValid(true)
{
    // m_alpha = 10000. / 2.99792458 / m_bField;
    // m_alpha = 333.564095;
    m_bField = 10 * VertexFitBField::instance()->getBFieldZRef();
    m_alpha = 10000. / 2.99792458 / m_bField; 
    //std::cout << "m_bField =  " << m_bField << "   m_alpha = " << m_alpha << std::endl;
    updateCache();
}

VFHelix() [2/3]

VFHelix::VFHelix	(	const HepPoint3D &	pivot,
		const HepVector &	a )

Constructor without error matrix.

Definition at line 55 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

: m_bField(10.0),
  m_alpha(333.564095),
  m_pivot(pivot),
  m_a(a),
  m_Ea(HepSymMatrix(5,0)),
  m_matrixValid(false)
{
    // m_alpha = 333.564095;
    m_bField = 10 * VertexFitBField::instance()->getBFieldZRef();
    m_alpha = 10000. / 2.99792458 / m_bField;
 
    updateCache();
}

VFHelix() [3/3]

VFHelix::VFHelix	(	const HepPoint3D &	position,
		const Hep3Vector &	momentum,
		double	charge )

Constructor with position, momentum, and charge.

Definition at line 71 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

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

~VFHelix()

VFHelix::~VFHelix ( )

virtual

Destructor.

Definition at line 106 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                  {
}

Member Function Documentation

a() [1/2]

const HepVector & VFHelix::a ( const HepVector & newA )

inline

sets helix parameters.

Definition at line 252 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                              {
    m_a = i;
    updateCache();
    return m_a;
}

a() [2/2]

const HepVector & VFHelix::a ( void ) const

inline

returns helix parameters.

Definition at line 240 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                     {
    return m_a;
}

Referenced by bFieldZ(), CalibEventSelect::execute(), DQAKsKpi::execute(), DQAKsKpiDEDX::execute(), DQAPi2p2::execute(), DQASelHadron::execute(), DTagSetAlg::execute(), Gam4pikp::execute(), LTagSetAlg::execute(), Rhopi::execute(), SD0Tag::execute(), Single::execute(), TagSetAlg::execute(), XYZTagSetAlg::execute(), DSemilepAlg::isGoodTrack(), DTagTool::isGoodTrack(), DTagTool::isGoodTrack_loose(), K0kk::MTotal(), K0kpi::MTotal(), K0pi0::MTotal(), K0pipi::MTotal(), K0pipipi0::MTotal(), K3pi::MTotal(), K3pipi0::MTotal(), Kk::MTotal(), Kkpi0::MTotal(), Kkpipi::MTotal(), Kpi::MTotal(), Kpipi0::MTotal(), Kpipi0pi0::MTotal(), Pipi::MTotal(), Pipipi0::MTotal(), LocalKaonSelector::operator()(), LocalPionSelector::operator()(), LocalProtonSelector::operator()(), and set().

bFieldZ() [1/2]

double VFHelix::bFieldZ ( double a )

inline

sets/returns z componet of the magnetic field.

Definition at line 266 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

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

bFieldZ() [2/2]

double VFHelix::bFieldZ ( void ) const

inline

Definition at line 275 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                           {
    return m_bField;
}

center()

const HepPoint3D & VFHelix::center ( void ) const

inline

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

Definition at line 180 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                          {
    return m_center;
}

cosPhi0()

double VFHelix::cosPhi0 ( void ) const

inline

Definition at line 287 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                           {
    return m_cp;
}

curv()

double VFHelix::curv ( void ) const

inline

Definition at line 234 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                        {
    return m_r;
}

del4MDelA()

HepMatrix VFHelix::del4MDelA	(	double	phi,
		double	mass ) const

Definition at line 578 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                                {
    //
    //   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;
}

Referenced by momentum().

del4MXDelA()

HepMatrix VFHelix::del4MXDelA	(	double	phi,
		double	mass ) const

Definition at line 624 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                                 {
    //
    //   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;
}

Referenced by momentum().

delApDelA()

HepMatrix VFHelix::delApDelA

(

const HepVector &

ap

)

const

Definition at line 419 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                             {
    //
    //   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;
}

Referenced by pivot().

delMDelA()

HepMatrix VFHelix::delMDelA

(

double

phi

)

const

Definition at line 541 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                  {
    //
    //   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;
}

Referenced by momentum().

delXDelA()

HepMatrix VFHelix::delXDelA

(

double

phi

)

const

Definition at line 487 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                  {
    //
    //   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;
}

Referenced by x().

direction()

Hep3Vector VFHelix::direction ( double dPhi = 0. ) const

inline

returns direction vector after rotating angle dPhi in phi direction.

Definition at line 198 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

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

dr()

double VFHelix::dr ( void ) const

inline

returns an element of parameters.

Definition at line 204 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                      {
    return m_ac[0];
}

Referenced by del4MXDelA(), delApDelA(), delXDelA(), and pivot().

dz()

double VFHelix::dz ( void ) const

inline

Definition at line 222 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                      {
    return m_ac[3];
}

Referenced by del4MXDelA(), delApDelA(), delXDelA(), and pivot().

Ea() [1/2]

const HepSymMatrix & VFHelix::Ea ( const HepSymMatrix & newdA )

inline

sets helix paramters and error matrix.

Definition at line 260 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                                  {
    return m_Ea = i;
}

Ea() [2/2]

const HepSymMatrix & VFHelix::Ea ( void ) const

inline

returns error matrix.

Definition at line 246 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                      {
    return m_Ea;
}

Referenced by set().

ignoreErrorMatrix()

void VFHelix::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 695 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

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

kappa()

double VFHelix::kappa ( void ) const

inline

Definition at line 216 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                         {
    return m_ac[2];
}

Referenced by pivot().

momentum() [1/5]

HepLorentzVector VFHelix::momentum	(	double	dPhi,
		double	mass ) const

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

Definition at line 208 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                               {
    // 
    // 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 VFHelix::momentum	(	double	dPhi,
		double	mass,
		HepPoint3D &	x,
		HepSymMatrix &	Emx ) const

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

Definition at line 256 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                  {
  // 
  // 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 VFHelix::momentum	(	double	dPhi,
		double	mass,
		HepSymMatrix &	Em ) const

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

Definition at line 231 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                                                  {
    // 
    // 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 VFHelix::momentum	(	double	dPhi,
		HepSymMatrix &	Em ) const

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 185 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                                     {
    // 
    // 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 VFHelix::momentum

(

double

dPhi = 0.

)

const

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 165 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                  {
    // 
    // 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=()

VFHelix & VFHelix::operator=

(

const VFHelix &

i

)

Copy operator.

Definition at line 361 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                      {
    if (this == & i) return * this;
 
    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 VFHelix::phi0 ( void ) const

inline

Definition at line 210 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                        {
    return m_ac[1];
}

Referenced by del4MDelA(), del4MXDelA(), delApDelA(), delMDelA(), delXDelA(), and pivot().

pivot() [1/2]

const HepPoint3D & VFHelix::pivot

(

const HepPoint3D &

newPivot

)

sets pivot position.

Definition at line 289 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                          {
    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;
}

pivot() [2/2]

const HepPoint3D & VFHelix::pivot ( void ) const

inline

returns pivot position.

Definition at line 186 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                         {
    return m_pivot;
}

Referenced by CalibEventSelect::execute(), DQAKsKpi::execute(), DQAKsKpiDEDX::execute(), DQAPi2p2::execute(), DQASelHadron::execute(), DTagSetAlg::execute(), Gam4pikp::execute(), LTagSetAlg::execute(), Rhopi::execute(), SD0Tag::execute(), Single::execute(), TagSetAlg::execute(), XYZTagSetAlg::execute(), DSemilepAlg::isGoodTrack(), DTagTool::isGoodTrack(), DTagTool::isGoodTrack_loose(), K0kk::MTotal(), K0kpi::MTotal(), K0pi0::MTotal(), K0pipi::MTotal(), K0pipipi0::MTotal(), K3pi::MTotal(), K3pipi0::MTotal(), Kk::MTotal(), Kkpi0::MTotal(), Kkpipi::MTotal(), Kpi::MTotal(), Kpipi0::MTotal(), Kpipi0pi0::MTotal(), Pipi::MTotal(), Pipipi0::MTotal(), LocalKaonSelector::operator()(), LocalPionSelector::operator()(), LocalProtonSelector::operator()(), and set().

radius()

double VFHelix::radius ( void ) const

inline

returns radious of helix.

Definition at line 192 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                          {
    return m_r;
}

set()

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

sets helix pivot position, parameters, and error matrix.

Definition at line 350 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

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

sinPhi0()

double VFHelix::sinPhi0 ( void ) const

inline

Definition at line 281 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                           {
    return m_sp;
}

tanl()

double VFHelix::tanl ( void ) const

inline

Definition at line 228 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

                        {
    return m_ac[4];
}

Referenced by pivot().

x() [1/3]

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

Definition at line 127 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                        {
    //
    // 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 VFHelix::x	(	double	dPhi,
		HepSymMatrix &	Ex ) const

returns position and convariance matrix(Ex) after rotation.

Definition at line 144 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                                              {
    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 VFHelix::x

(

double

dPhi = 0.

)

const

returns position after rotating angle dPhi in phi direction.

Definition at line 110 of file Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx.

                           {
    //
    // 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);
}

Referenced by x(), and x().

Member Data Documentation

ConstantAlpha

const double VFHelix::ConstantAlpha = 333.564095

static

Constant alpha for uniform field.

Definition at line 148 of file Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h.

---

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

• Analysis/VertexFit/VertexFit-00-03-06/VertexFit/Helix.h
• Analysis/VertexFit/VertexFit-00-03-06/src/Helix.cxx