Dedx_Helix Class Reference

Helix parameter class. More...

#include <Dedx_Helix.h>

List of all members.

Public Member Functions
	Dedx_Helix (const HepPoint3D &pivot, const HepVector &a, const HepSymMatrix &Ea)
	Constructor with pivot, helix parameter a, and its error matrix.
	Dedx_Helix (const HepPoint3D &pivot, const HepVector &a)
	Constructor without error matrix.
	Dedx_Helix (const HepPoint3D &position, const Hep3Vector &momentum, double charge)
	Constructor with position, momentum, and charge.
virtual	~Dedx_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
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
Dedx_Helix &	operator= (const Dedx_Helix &)
	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.
Private Member Functions
void	updateCache (void)
Private Attributes
IMagneticFieldSvc *	m_pmgnIMF
double	m_bField
double	m_alpha
HepPoint3D	m_pivot
HepVector	m_a
HepSymMatrix	m_Ea
bool	m_matrixValid
HepPoint3D	m_center
double	m_cp
double	m_sp
double	m_pt
double	m_r
double	m_ac [5]

---

Detailed Description

Helix parameter class.

Definition at line 33 of file Dedx_Helix.h.

---

Constructor & Destructor Documentation

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

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

Definition at line 126 of file Dedx_Helix.cxx.

References IMagneticFieldSvc::getReferField(), m_alpha, m_bField, m_pmgnIMF, and updateCache().

: //m_bField(10.0),
  //m_alpha(333.564095),
  m_pivot(pivot),
  m_a(a),
  m_matrixValid(true),
  m_Ea(Ea) {
    //ISvcLocator * SvcLocator = Gaudi::SvcLocator(); 
    StatusCode scmgn = Gaudi::svcLocator()->service("MagneticFieldSvc",m_pmgnIMF); 
    if(scmgn!=StatusCode::SUCCESS) { 
     // log << MSG::ERROR << "Unable to open Magnetic field service"<<endreq; 
     std::cout<< "Unable to open Magnetic field service"<<std::endl;
    }
    m_bField = 10000*(m_pmgnIMF->getReferField());
    m_alpha = 10000. / 2.99792458 / m_bField;
    // m_alpha = 222.376063;
    updateCache();
}

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

Constructor without error matrix.

Definition at line 147 of file Dedx_Helix.cxx.

References IMagneticFieldSvc::getReferField(), m_alpha, m_bField, m_pmgnIMF, and updateCache().

: //m_bField(10.0),
  //m_alpha(333.564095),
  m_pivot(pivot),
  m_a(a),
  m_matrixValid(false),
  m_Ea(HepSymMatrix(5,0)) {
    StatusCode scmgn = Gaudi::svcLocator()->service ("MagneticFieldSvc",m_pmgnIMF);
    if(scmgn!=StatusCode::SUCCESS) {
     // log << MSG::ERROR << "Unable to open Magnetic field service"<<endreq;
     std::cout<< "Unable to open Magnetic field service"<<std::endl;
    }
    m_bField = 10000*(m_pmgnIMF->getReferField());
    m_alpha = 10000. / 2.99792458 / m_bField;
    //cout<<"m_bField is = "<<m_bField<<"        m_alpha is = "<<m_alpha<<endl;
    // m_alpha = 222.376063;
    updateCache();
}

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

Constructor with position, momentum, and charge.

Definition at line 167 of file Dedx_Helix.cxx.

References DBL_MAX, IMagneticFieldSvc::getReferField(), m_a, m_alpha, m_bField, M_PI2, M_PI4, m_pmgnIMF, and updateCache().

: //m_bField(10.0),
  //m_alpha(333.564095),
  m_pivot(position),
  m_a(HepVector(5,0)),
  m_matrixValid(false),
  m_Ea(HepSymMatrix(5,0)) {
    StatusCode scmgn = Gaudi::svcLocator()->service ("MagneticFieldSvc",m_pmgnIMF);
    if(scmgn!=StatusCode::SUCCESS) {
     // log << MSG::ERROR << "Unable to open Magnetic field service"<<endreq;
     std::cout<< "Unable to open Magnetic field service"<<std::endl;
    }
    m_bField = 10000*(m_pmgnIMF->getReferField());
    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 = 222.376063;
    updateCache();
}

Dedx_Helix::~Dedx_Helix

(

)

[virtual]

Destructor.

Definition at line 205 of file Dedx_Helix.cxx.

                        {
}

---

Member Function Documentation

const HepVector & Dedx_Helix::a

(

const HepVector &

newA

)

[inline]

sets helix parameters.

Definition at line 250 of file Dedx_Helix.h.

References m_a, and updateCache().

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

const HepVector & Dedx_Helix::a

(

void

)

const [inline]

returns helix parameters.

Definition at line 238 of file Dedx_Helix.h.

References m_a.

Referenced by DedxCorrecSvc::PathL().

                        {
    return m_a;
}

double Dedx_Helix::bFieldZ

(

void

)

const [inline]

Definition at line 273 of file Dedx_Helix.h.

References m_bField.

                              {
    return m_bField;
}

double Dedx_Helix::bFieldZ

(

double

)

[inline]

sets/returns z componet of the magnetic field.

Definition at line 264 of file Dedx_Helix.h.

References m_alpha, m_bField, and updateCache().

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

const HepPoint3D & Dedx_Helix::center

(

void

)

const [inline]

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

Definition at line 178 of file Dedx_Helix.h.

References m_center.

                             {
    return m_center;
}

double Dedx_Helix::cosPhi0

(

void

)

const [inline]

Definition at line 285 of file Dedx_Helix.h.

References m_cp.

                              {
    return m_cp;
}

double Dedx_Helix::curv

(

void

)

const [inline]

Definition at line 232 of file Dedx_Helix.h.

References m_r.

                           {
    return m_r;
}

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

Definition at line 681 of file Dedx_Helix.cxx.

References cos(), DBL_MAX, m_ac, phi0(), and sin().

Referenced by momentum().

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

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

Definition at line 727 of file Dedx_Helix.cxx.

References cos(), DBL_MAX, dr(), dz(), m_ac, m_cp, m_r, m_sp, phi0(), and sin().

Referenced by momentum().

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

HepMatrix Dedx_Helix::delApDelA

(

const HepVector &

ap

)

const

Definition at line 522 of file Dedx_Helix.cxx.

References cos(), DBL_MAX, dr(), dz(), m_ac, M_PI, M_PI2, M_PI8, m_r, phi0(), and sin().

Referenced by pivot().

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

HepMatrix Dedx_Helix::delMDelA

(

double

phi

)

const

Definition at line 644 of file Dedx_Helix.cxx.

References cos(), DBL_MAX, m_ac, phi0(), and sin().

Referenced by momentum().

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

HepMatrix Dedx_Helix::delXDelA

(

double

phi

)

const

Definition at line 590 of file Dedx_Helix.cxx.

References cos(), DBL_MAX, dr(), dz(), m_ac, m_cp, m_r, m_sp, phi0(), and sin().

Referenced by x().

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

Hep3Vector Dedx_Helix::direction

(

double

dPhi = 0.

)

const [inline]

returns direction vector after rotating angle dPhi in phi direction.

Definition at line 196 of file Dedx_Helix.h.

References momentum().

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

double Dedx_Helix::dr

(

void

)

const [inline]

returns an element of parameters.

Definition at line 202 of file Dedx_Helix.h.

References m_ac.

Referenced by del4MXDelA(), delApDelA(), delXDelA(), DedxCorrecSvc::PathL(), and pivot().

                         {
    return m_ac[0];
}

double Dedx_Helix::dz

(

void

)

const [inline]

Definition at line 220 of file Dedx_Helix.h.

References m_ac.

Referenced by del4MXDelA(), delApDelA(), delXDelA(), DedxCorrecSvc::PathL(), and pivot().

                         {
    return m_ac[3];
}

const HepSymMatrix & Dedx_Helix::Ea

(

const HepSymMatrix &

newdA

)

[inline]

sets helix paramters and error matrix.

Definition at line 258 of file Dedx_Helix.h.

References m_Ea.

                                     {
    return m_Ea = i;
}

const HepSymMatrix & Dedx_Helix::Ea

(

void

)

const [inline]

returns error matrix.

Definition at line 244 of file Dedx_Helix.h.

References m_Ea.

                         {
    return m_Ea;
}

void Dedx_Helix::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 798 of file Dedx_Helix.cxx.

References m_Ea, and m_matrixValid.

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

double Dedx_Helix::kappa

(

void

)

const [inline]

Definition at line 214 of file Dedx_Helix.h.

References m_ac.

Referenced by pivot().

                            {
    return m_ac[2];
}

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

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

Definition at line 359 of file Dedx_Helix.cxx.

References cos(), del4MXDelA(), m_ac, m_cp, m_Ea, m_matrixValid, m_pivot, m_pt, m_r, m_sp, and sin().

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

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

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

Definition at line 334 of file Dedx_Helix.cxx.

References cos(), del4MDelA(), m_ac, m_Ea, m_matrixValid, m_pt, and sin().

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

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

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

Definition at line 311 of file Dedx_Helix.cxx.

References cos(), m_ac, m_pt, and sin().

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

Hep3Vector Dedx_Helix::momentum	(	double	dPhi,
		HepSymMatrix &	Em
	)			const

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 288 of file Dedx_Helix.cxx.

References cos(), delMDelA(), m_ac, m_Ea, m_matrixValid, m_pt, and sin().

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

Hep3Vector Dedx_Helix::momentum

(

double

dPhi = 0.

)

const

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 268 of file Dedx_Helix.cxx.

References cos(), m_ac, m_pt, and sin().

Referenced by direction().

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

Dedx_Helix & Dedx_Helix::operator=

(

const Dedx_Helix &

)

Copy operator.

Definition at line 464 of file Dedx_Helix.cxx.

References genRecEmupikp::i, m_a, m_ac, m_alpha, m_bField, m_center, m_cp, m_Ea, m_matrixValid, m_pivot, m_pt, m_r, and m_sp.

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

double Dedx_Helix::phi0

(

void

)

const [inline]

Definition at line 208 of file Dedx_Helix.h.

References m_ac.

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

                           {
    return m_ac[1];
}

const HepPoint3D & Dedx_Helix::pivot

(

const HepPoint3D &

newPivot

)

sets pivot position.

Definition at line 392 of file Dedx_Helix.cxx.

References cos(), delApDelA(), dr(), dz(), kappa(), m_a, m_ac, m_Ea, m_matrixValid, M_PI, M_PI2, M_PI4, M_PI8, m_pivot, m_r, phi0(), tanl(), and updateCache().

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

const HepPoint3D & Dedx_Helix::pivot

(

void

)

const [inline]

returns pivot position.

Definition at line 184 of file Dedx_Helix.h.

References m_pivot.

Referenced by DedxCorrecSvc::PathL().

                            {
    return m_pivot;
}

double Dedx_Helix::radius

(

void

)

const [inline]

returns radious of helix.

Definition at line 190 of file Dedx_Helix.h.

References m_r.

                             {
    return m_r;
}

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

sets helix pivot position, parameters, and error matrix.

Definition at line 453 of file Dedx_Helix.cxx.

References m_a, m_Ea, m_matrixValid, m_pivot, and updateCache().

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

double Dedx_Helix::sinPhi0

(

void

)

const [inline]

Definition at line 279 of file Dedx_Helix.h.

References m_sp.

                              {
    return m_sp;
}

double Dedx_Helix::tanl

(

void

)

const [inline]

Definition at line 226 of file Dedx_Helix.h.

References m_ac.

Referenced by pivot().

                           {
    return m_ac[4];
}

void Dedx_Helix::updateCache

(

void

)

[private]

Definition at line 489 of file Dedx_Helix.cxx.

References cos(), DBL_MAX, m_a, m_ac, m_alpha, m_center, m_cp, m_pivot, m_pt, m_r, m_sp, sin(), and x().

Referenced by a(), bFieldZ(), Dedx_Helix(), pivot(), and set().

                            {
    //
    //   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) {
        m_pt = 1. / m_ac[2];
        m_r = m_alpha / m_ac[2];
    }
    else {
        m_pt = (DBL_MAX);
        m_r = (DBL_MAX);
    }

    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.);
}

HepPoint3D Dedx_Helix::x	(	double	dPhi,
		HepSymMatrix &	Ex
	)			const

returns position and convariance matrix(Ex) after rotation.

Definition at line 247 of file Dedx_Helix.cxx.

References cos(), delXDelA(), m_ac, m_cp, m_Ea, m_matrixValid, m_pivot, m_r, m_sp, sin(), and x().

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

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

Definition at line 230 of file Dedx_Helix.cxx.

References cos(), m_ac, m_cp, m_pivot, m_r, m_sp, and sin().

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

HepPoint3D Dedx_Helix::x

(

double

dPhi = 0.

)

const

returns position after rotating angle dPhi in phi direction.

Definition at line 209 of file Dedx_Helix.cxx.

References cos(), m_ac, m_cp, m_pivot, m_r, m_sp, and sin().

Referenced by DedxCorrecSvc::PathL(), updateCache(), and x().

                              {
    //
    // 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
    //
   // m_ac[0] = m_ac[0] *(-1);
    // cout<<"m_bField is = "<<m_bField<<"        m_alpha is = "<<m_alpha<<endl;
  // cout<<"m_pivot is = "<<m_pivot<<"       m_ac is = ("<<m_ac[0]<<" , "<<m_ac[1]<<" , "<<m_ac[2]<<" , "<<m_ac[3]<<" , "<<m_ac[4]<<" )"<<endl;
  //cout<<"m_cp is = "<<m_cp<<"     "<<"   m_sp is =  "<<m_sp<<"      m_r is =  "<<m_r<<endl;  
    //cout<<" m_r + m_ac[0] = "<<m_ac[0] +m_r<<endl;
    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

const double Dedx_Helix::ConstantAlpha = -333.564095 [static]

Constant alpha for uniform field.

Definition at line 146 of file Dedx_Helix.h.

HepVector Dedx_Helix::m_a [private]

Definition at line 152 of file Dedx_Helix.h.

Referenced by a(), Dedx_Helix(), operator=(), pivot(), set(), and updateCache().

double Dedx_Helix::m_ac[5] [private]

Definition at line 162 of file Dedx_Helix.h.

Referenced by del4MDelA(), del4MXDelA(), delApDelA(), delMDelA(), delXDelA(), dr(), dz(), kappa(), momentum(), operator=(), phi0(), pivot(), tanl(), updateCache(), and x().

double Dedx_Helix::m_alpha [private]

Definition at line 150 of file Dedx_Helix.h.

Referenced by bFieldZ(), Dedx_Helix(), operator=(), and updateCache().

double Dedx_Helix::m_bField [private]

Definition at line 149 of file Dedx_Helix.h.

Referenced by bFieldZ(), Dedx_Helix(), and operator=().

HepPoint3D Dedx_Helix::m_center [private]

Definition at line 157 of file Dedx_Helix.h.

Referenced by center(), operator=(), and updateCache().

double Dedx_Helix::m_cp [private]

Definition at line 158 of file Dedx_Helix.h.

Referenced by cosPhi0(), del4MXDelA(), delXDelA(), momentum(), operator=(), updateCache(), and x().

HepSymMatrix Dedx_Helix::m_Ea [private]

Definition at line 153 of file Dedx_Helix.h.

Referenced by Ea(), ignoreErrorMatrix(), momentum(), operator=(), pivot(), set(), and x().

bool Dedx_Helix::m_matrixValid [private]

Definition at line 154 of file Dedx_Helix.h.

Referenced by ignoreErrorMatrix(), momentum(), operator=(), pivot(), set(), and x().

HepPoint3D Dedx_Helix::m_pivot [private]

Definition at line 151 of file Dedx_Helix.h.

Referenced by momentum(), operator=(), pivot(), set(), updateCache(), and x().

IMagneticFieldSvc* Dedx_Helix::m_pmgnIMF [private]

Definition at line 139 of file Dedx_Helix.h.

Referenced by Dedx_Helix().

double Dedx_Helix::m_pt [private]

Definition at line 160 of file Dedx_Helix.h.

Referenced by momentum(), operator=(), and updateCache().

double Dedx_Helix::m_r [private]

Definition at line 161 of file Dedx_Helix.h.

Referenced by curv(), del4MXDelA(), delApDelA(), delXDelA(), momentum(), operator=(), pivot(), radius(), updateCache(), and x().

double Dedx_Helix::m_sp [private]

Definition at line 159 of file Dedx_Helix.h.

Referenced by del4MXDelA(), delXDelA(), momentum(), operator=(), sinPhi0(), updateCache(), and x().

---