KalmanFit::Helix Class Reference

Helix parameter class. More...

#include <Helix.h>

Inheritance diagram for KalmanFit::Helix:

List of all members.

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
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.
double	approach (KalFitHitMdc &hit, bool doSagCorrection) const
double	approach (HepPoint3D pfwd, HepPoint3D pbwd, bool doSagCorrection) const
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
double	alpha (void) const
Helix &	operator= (const 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 41 of file Helix.h.

---

Constructor & Destructor Documentation

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

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

Definition at line 49 of file 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) {
  StatusCode scmgn = Gaudi::svcLocator()->service("MagneticFieldSvc",m_pmgnIMF); 
  if(scmgn!=StatusCode::SUCCESS) { 
    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 = 10000. / 2.99792458 / m_bField;
  // m_alpha = 333.564095;
  updateCache();
}

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

Constructor without error matrix.

Definition at line 69 of file 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;
    // m_alpha = 333.564095;
 //cout<<"MdcFastTrakAlg:: bField,alpha: "<<m_bField<<" , "<<m_alpha<<endl;
    updateCache();
}

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

Constructor with position, momentum, and charge.

Definition at line 89 of file 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 = 333.564095;
    updateCache();
}

Helix::~Helix

(

)

[virtual]

Destructor.

Definition at line 127 of file Helix.cxx.

              {
}

---

Member Function Documentation

const HepVector & Helix::a

(

const HepVector &

newA

)

[inline]

sets helix parameters.

Definition at line 266 of file Helix.h.

References Helix::m_a, and Helix::updateCache().

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

const HepVector & Helix::a

(

void

)

const [inline]

returns helix parameters.

Definition at line 254 of file Helix.h.

References Helix::m_a.

Referenced by approach(), KalFitAlg::complete_track(), KalFitTrack::eloss(), KalFitAlg::fillTds(), KalFitAlg::fillTds_back(), KalFitAlg::fillTds_ip(), KalFitAlg::fillTds_lead(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), KalFitTrack::pivot_numf(), KalFitTrack::radius_numf(), KalFitAlg::smoother_anal(), KalFitAlg::smoother_calib(), KalFitAlg::start_seed(), KalFitTrack::update_forMdc(), and KalFitTrack::update_last().

                   {
    return m_a;
}

double Helix::alpha

(

void

)

const [inline]

Definition at line 292 of file Helix.h.

References Helix::m_alpha.

                       {

  return m_alpha;
}

double Helix::approach	(	HepPoint3D	pfwd,
		HepPoint3D	pbwd,
		bool	doSagCorrection
	)			const

Definition at line 208 of file KalFitDoca.cxx.

References a(), center(), ConstantAlpha, cos(), Ea(), first, kappa(), phi0(), pivot(), sin(), tanl(), v, and x().

{
// ...Cal. dPhi to rotate...
// const TMDCWire & w = * link.wire();
    HepPoint3D positionOnWire, positionOnTrack;
    HepPoint3D pv = pivot();
    HepVector Va = a();
    HepSymMatrix Ma = Ea(); 

    Helix _helix(pv, Va ,Ma);
    Hep3Vector Wire;
    Wire[0] = (pfwd - pbwd).x();
    Wire[1] = (pfwd - pbwd).y();
    Wire[2] = (pfwd - pbwd).z(); 
// xyPosition(), returns middle position of a wire. z componet is 0.
// w.xyPosition(wp);
    double wp[3]; 
    wp[0] = 0.5*(pfwd + pbwd).x();   
    wp[1] = 0.5*(pfwd + pbwd).y();
    wp[2] = 0.;
    double wb[3]; 
// w.backwardPosition(wb);
    wb[0] = pbwd.x();
    wb[1] = pbwd.y();
    wb[2] = pbwd.z();
    double v[3];
    v[0] = Wire.unit().x();
    v[1] = Wire.unit().y();
    v[2] = Wire.unit().z();
// std::cout<<"Wire.unit() is "<<Wire.unit()<<std::endl; 

// ...Sag correction...
    /* if (doSagCorrection) {
        HepVector3D dir = w.direction();
        HepPoint3D xw(wp[0], wp[1], wp[2]);
        HepPoint3D wireBackwardPosition(wb[0], wb[1], wb[2]);
        w.wirePosition(link.positionOnTrack().z(),
                       xw,
                       wireBackwardPosition,
                       dir);
        v[0] = dir.x();
        v[1] = dir.y();
        v[2] = dir.z();
        wp[0] = xw.x();
        wp[1] = xw.y();
        wp[2] = xw.z();
        wb[0] = wireBackwardPosition.x();
        wb[1] = wireBackwardPosition.y();
        wb[2] = wireBackwardPosition.z();
     }
    */
    // ...Cal. dPhi to rotate...
    const HepPoint3D & xc = _helix.center();
    double xt[3];
     _helix.x(0., xt);
    double x0 = - xc.x();
    double y0 = - xc.y();
    double x1 = wp[0] + x0;
    double y1 = wp[1] + y0;
    x0 += xt[0];
    y0 += xt[1];
    //std::cout<<" x0 is: "<<x0<<" y0 is: "<<y0<<std::endl;
    //std::cout<<" x1 is: "<<x1<<" y1 is: "<<y1<<std::endl;
    //std::cout<<" xt[0] is: "<<xt[0]<<" xt[1] is: "<<xt[1]<<std::endl;

    double dPhi = atan2(x0 * y1 - y0 * x1, x0 * x1 + y0 * y1);
    //std::cout<<" x0 * y1 - y0 * x1 is: "<<(x0 * y1 - y0 * x1)<<std::endl;
    //std::cout<<" x0 * x1 + y0 * y1 is: "<<(x0 * x1 + y0 * y1)<<std::endl;
    //std::cout<<" before loop dPhi is "<<dPhi<<std::endl;
    //...Setup...
    double kappa = _helix.kappa();
    double phi0 = _helix.phi0();

    //...Axial case...
  /*  if (!w.stereo()) {
        positionOnTrack = _helix.x(dPhi);
        HepPoint3D x(wp[0], wp[1], wp[2]);
        x.setZ(positionOnTrack.z());
         positionOnWire = x;
     //link.dPhi(dPhi);
     std::cout<<" in axial wire : positionOnTrack is "<<positionOnTrack
              <<" positionOnWire is "<<positionOnWire<<std::endl;
         return (positionOnTrack - positionOnWire).mag();
    }
   */
    double firstdfdphi = 0.;
    static bool first = true;
    if (first) {
//      extern BelleTupleManager * BASF_Histogram;
//      BelleTupleManager * m = BASF_Histogram;
//      h_nTrial = m->histogram("TTrack::approach nTrial", 100, 0., 100.);
    }
//#endif

    //...Stereo case...
    double rho = Helix::ConstantAlpha / kappa;
    double tanLambda = _helix.tanl();
    static HepPoint3D x;
    double t_x[3];
    double t_dXdPhi[3];
    const double convergence = 1.0e-5;
    double l;
    unsigned nTrial = 0;
    while (nTrial < 100) {

// x = link.positionOnTrack(_helix->x(dPhi));
        positionOnTrack = _helix.x(dPhi);
        x = _helix.x(dPhi);
        t_x[0] = x[0];
        t_x[1] = x[1];
        t_x[2] = x[2];

        l = v[0] * t_x[0] + v[1] * t_x[1] + v[2] * t_x[2]
            - v[0] * wb[0] - v[1] * wb[1] - v[2] * wb[2];

        double rcosPhi = rho * cos(phi0 + dPhi);
        double rsinPhi = rho * sin(phi0 + dPhi);
        t_dXdPhi[0] =   rsinPhi;
        t_dXdPhi[1] = - rcosPhi;
        t_dXdPhi[2] = - rho * tanLambda;

        //...f = d(Distance) / d phi...
        double t_d2Xd2Phi[2];
        t_d2Xd2Phi[0] = rcosPhi;
        t_d2Xd2Phi[1] = rsinPhi;

        //...iw new...
        double n[3];
        n[0] = t_x[0] - wb[0];
        n[1] = t_x[1] - wb[1];
        n[2] = t_x[2] - wb[2];
        
        double a[3];
        a[0] = n[0] - l * v[0];
        a[1] = n[1] - l * v[1];
        a[2] = n[2] - l * v[2];
        double dfdphi = a[0] * t_dXdPhi[0]
            + a[1] * t_dXdPhi[1]
            + a[2] * t_dXdPhi[2];

        if (nTrial == 0) {
//          break;
            firstdfdphi = dfdphi;
        }

        //...Check bad case...
        if (nTrial > 3) {
//          std::cout<<" BAD CASE!!, calculate approach ntrial = "<<nTrial<< endl;
        }
        //...Is it converged?...
        if (fabs(dfdphi) < convergence)
            break;

        double dv = v[0] * t_dXdPhi[0]
            + v[1] * t_dXdPhi[1]
            + v[2] * t_dXdPhi[2];
        double t0 = t_dXdPhi[0] * t_dXdPhi[0]
            + t_dXdPhi[1] * t_dXdPhi[1]
            + t_dXdPhi[2] * t_dXdPhi[2];
        double d2fd2phi = t0 - dv * dv
            + a[0] * t_d2Xd2Phi[0]
            + a[1] * t_d2Xd2Phi[1];
        //  + a[2] * t_d2Xd2Phi[2];

        dPhi -= dfdphi / d2fd2phi;
        ++nTrial;
    }
    //std::cout<<" dPhi is: "<<dPhi<<std::endl;
    //...Cal. positions...
    positionOnWire[0] = wb[0] + l * v[0];
    positionOnWire[1] = wb[1] + l * v[1];
    positionOnWire[2] = wb[2] + l * v[2];

    //std::cout<<"wb[0] is: "<<wb[0]<<" l is: "<<l<<" v[0] is: "<<v[0]<<std::endl;
    //std::cout<<"wb[1] is: "<<wb[1]<<" v[1] is: "<<v[1]<<std::endl;
    //std::cout<<"wb[2] is: "<<wb[2]<<" v[2] is: "<<v[2]<<std::endl;

    //std::cout<<" positionOnTrack is "<<positionOnTrack
    //         <<" positionOnWire is "<<positionOnWire<<std::endl;

    return (positionOnTrack - positionOnWire).mag();
    // link.dPhi(dPhi);
    // return nTrial;
}

double Helix::approach	(	KalFitHitMdc &	hit,
		bool	doSagCorrection
	)			const

Definition at line 16 of file KalFitDoca.cxx.

References a(), center(), ConstantAlpha, cos(), Ea(), first, kappa(), phi0(), pivot(), sin(), tanl(), v, w, KalFitHitMdc::wire(), and x().

                                                             {
    //...Cal. dPhi to rotate...
    //const TMDCWire & w = * link.wire();
    HepPoint3D positionOnWire, positionOnTrack;
    HepPoint3D pv = pivot();
    //std::cout<<"the track pivot in approach is "<<pv<<std::endl;
    HepVector Va = a();
    //std::cout<<"the track parameters is "<<Va<<std::endl;
    HepSymMatrix Ma = Ea(); 
    //std::cout<<"the error matrix is "<<Ma<<std::endl;

    Helix _helix(pv, Va ,Ma);
    //_helix.pivot(IP);
    const KalFitWire& w = hit.wire();
    Hep3Vector Wire = w.fwd() - w.bck(); 
    //xyPosition(), returns middle position of a wire. z componet is 0.
    //w.xyPosition(wp);
    double wp[3]; 
    wp[0] = 0.5*(w.fwd() + w.bck()).x();   
    wp[1] = 0.5*(w.fwd() + w.bck()).y();
    wp[2] = 0.;
    double wb[3]; 
    //w.backwardPosition(wb);
    wb[0] = w.bck().x();
    wb[1] = w.bck().y();
    wb[2] = w.bck().z();
    double v[3];
    v[0] = Wire.unit().x();
    v[1] = Wire.unit().y();
    v[2] = Wire.unit().z();
    //std::cout<<"Wire.unit() is "<<Wire.unit()<<std::endl; 
    
    //...Sag correction...
    /* if (doSagCorrection) {
        HepVector3D dir = w.direction();
        HepPoint3D xw(wp[0], wp[1], wp[2]);
        HepPoint3D wireBackwardPosition(wb[0], wb[1], wb[2]);
        w.wirePosition(link.positionOnTrack().z(),
                       xw,
                       wireBackwardPosition,
                       dir);
        v[0] = dir.x();
        v[1] = dir.y();
        v[2] = dir.z();
        wp[0] = xw.x();
        wp[1] = xw.y();
        wp[2] = xw.z();
        wb[0] = wireBackwardPosition.x();
        wb[1] = wireBackwardPosition.y();
        wb[2] = wireBackwardPosition.z();
     }
    */
    //...Cal. dPhi to rotate...
    const HepPoint3D & xc = _helix.center();

    //std::cout<<" helix center: "<<xc<<std::endl;
    
    double xt[3]; _helix.x(0., xt);
    double x0 = - xc.x();
    double y0 = - xc.y();
    double x1 = wp[0] + x0;
    double y1 = wp[1] + y0;
    x0 += xt[0];
    y0 += xt[1];
    double dPhi = atan2(x0 * y1 - y0 * x1, x0 * x1 + y0 * y1);
    
    //std::cout<<"dPhi is "<<dPhi<<std::endl;

    //...Setup...
    double kappa = _helix.kappa();
    double phi0 = _helix.phi0();

    //...Axial case...
  /*  if (!w.stereo()) {
        positionOnTrack = _helix.x(dPhi);
        HepPoint3D x(wp[0], wp[1], wp[2]);
        x.setZ(positionOnTrack.z());
         positionOnWire = x;
     //link.dPhi(dPhi);
     std::cout<<" in axial wire : positionOnTrack is "<<positionOnTrack
              <<" positionOnWire is "<<positionOnWire<<std::endl;
         return (positionOnTrack - positionOnWire).mag();
    }
   */
    double firstdfdphi = 0.;
    static bool first = true;
    if (first) {
//      extern BelleTupleManager * BASF_Histogram;
//      BelleTupleManager * m = BASF_Histogram;
//      h_nTrial = m->histogram("TTrack::approach nTrial", 100, 0., 100.);
    }
//#endif

    //...Stereo case...
    double rho = Helix::ConstantAlpha / kappa;
    double tanLambda = _helix.tanl();
    static HepPoint3D x;
    double t_x[3];
    double t_dXdPhi[3];
    const double convergence = 1.0e-5;
    double l;
    unsigned nTrial = 0;
    while (nTrial < 100) {

//      x = link.positionOnTrack(_helix->x(dPhi));
        positionOnTrack = _helix.x(dPhi);
        x = _helix.x(dPhi);
        t_x[0] = x[0];
        t_x[1] = x[1];
        t_x[2] = x[2];

        l = v[0] * t_x[0] + v[1] * t_x[1] + v[2] * t_x[2]
            - v[0] * wb[0] - v[1] * wb[1] - v[2] * wb[2];

        double rcosPhi = rho * cos(phi0 + dPhi);
        double rsinPhi = rho * sin(phi0 + dPhi);
        t_dXdPhi[0] =   rsinPhi;
        t_dXdPhi[1] = - rcosPhi;
        t_dXdPhi[2] = - rho * tanLambda;

        //...f = d(Distance) / d phi...
        double t_d2Xd2Phi[2];
        t_d2Xd2Phi[0] = rcosPhi;
        t_d2Xd2Phi[1] = rsinPhi;

        //...iw new...
        double n[3];
        n[0] = t_x[0] - wb[0];
        n[1] = t_x[1] - wb[1];
        n[2] = t_x[2] - wb[2];
        
        double a[3];
        a[0] = n[0] - l * v[0];
        a[1] = n[1] - l * v[1];
        a[2] = n[2] - l * v[2];
        double dfdphi = a[0] * t_dXdPhi[0]
            + a[1] * t_dXdPhi[1]
            + a[2] * t_dXdPhi[2];

//#ifdef TRKRECO_DEBUG
        if (nTrial == 0) {
//          break;
            firstdfdphi = dfdphi;
        }

        //...Check bad case...
        if (nTrial > 3) {
            std::cout<<" bad case, calculate approach ntrial = "<<nTrial<< std::endl;
        }
//#endif

        //...Is it converged?...
        if (fabs(dfdphi) < convergence)
            break;

        double dv = v[0] * t_dXdPhi[0]
            + v[1] * t_dXdPhi[1]
            + v[2] * t_dXdPhi[2];
        double t0 = t_dXdPhi[0] * t_dXdPhi[0]
            + t_dXdPhi[1] * t_dXdPhi[1]
            + t_dXdPhi[2] * t_dXdPhi[2];
        double d2fd2phi = t0 - dv * dv
            + a[0] * t_d2Xd2Phi[0]
            + a[1] * t_d2Xd2Phi[1];
//          + a[2] * t_d2Xd2Phi[2];

        dPhi -= dfdphi / d2fd2phi;

//      cout << "nTrial=" << nTrial << endl;
//      cout << "iw f,df,dphi=" << dfdphi << "," << d2fd2phi << "," << dPhi << endl;

        ++nTrial;
    }
    //...Cal. positions...
    positionOnWire[0] = wb[0] + l * v[0];
    positionOnWire[1] = wb[1] + l * v[1];
    positionOnWire[2] = wb[2] + l * v[2];
   
    //std::cout<<" positionOnTrack is "<<positionOnTrack
    //         <<" positionOnWire is "<<positionOnWire<<std::endl;
    return (positionOnTrack - positionOnWire).mag();

    //link.dPhi(dPhi);

    // #ifdef TRKRECO_DEBUG
    // h_nTrial->accumulate((float) nTrial + .5);
    // #endif
    // return nTrial;
}

double Helix::bFieldZ

(

void

)

const [inline]

Definition at line 300 of file Helix.h.

References Helix::m_bField.

                         {
    return m_bField;
}

double Helix::bFieldZ

(

double

)

[inline]

sets/returns z componet of the magnetic field.

Definition at line 280 of file Helix.h.

References Helix::m_alpha, Helix::m_bField, and Helix::updateCache().

Referenced by KalFitAlg::kalman_fitting_anal(), KalFitAlg::kalman_fitting_calib(), KalFitAlg::kalman_fitting_csmalign(), and KalFitAlg::kalman_fitting_MdcxReco_Csmc_Sew().

                       {
    m_bField = a;
    m_alpha = 10000. / 2.99792458 / m_bField;

    //std::cout<<"m_alpha: "<<m_alpha<<std::endl;
    updateCache();
    return m_bField;
}

const HepPoint3D & Helix::center

(

void

)

const [inline]

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

Definition at line 194 of file Helix.h.

References Helix::m_center.

Referenced by approach(), KalFitTrack::eloss(), KalFitAlg::fillTds_back(), KalFitTrack::intersect_cylinder(), KalFitTrack::intersect_yz_plane(), and KalFitTrack::intersect_zx_plane().

                        {
    return m_center;
}

double Helix::cosPhi0

(

void

)

const [inline]

Definition at line 312 of file Helix.h.

References Helix::m_cp.

                         {
    return m_cp;
}

double Helix::curv

(

void

)

const [inline]

Definition at line 248 of file Helix.h.

References Helix::m_r.

                      {
    return m_r;
}

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

Definition at line 605 of file Helix.cxx.

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

                                              {
    //
    //   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 Helix::del4MXDelA	(	double	phi,
		double	mass
	)			const

Definition at line 651 of file Helix.cxx.

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

                                               {
    //
    //   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 Helix::delApDelA

(

const HepVector &

ap

)

const

Definition at line 446 of file Helix.cxx.

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

Referenced by KalFitTrack::pivot_numf().

                                           {
    //
    //   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 Helix::delMDelA

(

double

phi

)

const

Definition at line 568 of file Helix.cxx.

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

                                {
    //
    //   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 Helix::delXDelA

(

double

phi

)

const

Definition at line 514 of file Helix.cxx.

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

                                {
    //
    //   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 Helix::direction

(

double

dPhi = 0.

)

const [inline]

returns direction vector after rotating angle dPhi in phi direction.

Definition at line 212 of file Helix.h.

References Helix::momentum().

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

double Helix::dr

(

void

)

const [inline]

returns an element of parameters.

Definition at line 218 of file Helix.h.

References Helix::m_ac.

Referenced by KalFitTrack::pivot_numf(), and KalFitTrack::radius_numf().

                    {
    return m_ac[0];
}

double Helix::dz

(

void

)

const [inline]

Definition at line 236 of file Helix.h.

References Helix::m_ac.

Referenced by KalFitTrack::intersect_xy_plane(), KalFitTrack::pivot_numf(), and KalFitTrack::radius_numf().

                    {
    return m_ac[3];
}

const HepSymMatrix & Helix::Ea

(

const HepSymMatrix &

newdA

)

[inline]

sets helix paramters and error matrix.

Definition at line 274 of file Helix.h.

References Helix::m_Ea.

                                {
    return m_Ea = i;
}

const HepSymMatrix & Helix::Ea

(

void

)

const [inline]

returns error matrix.

Definition at line 260 of file Helix.h.

References Helix::m_Ea.

Referenced by approach(), KalFitTrack::eloss(), KalFitAlg::fillTds(), KalFitAlg::fillTds_back(), KalFitAlg::fillTds_ip(), KalFitAlg::fillTds_lead(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), KalFitAlg::kalman_fitting_calib(), KalFitAlg::kalman_fitting_csmalign(), KalFitAlg::kalman_fitting_MdcxReco_Csmc_Sew(), KalFitTrack::ms(), KalFitTrack::msgasmdc(), KalFitTrack::pivot_numf(), KalFitAlg::smoother_anal(), KalFitAlg::smoother_calib(), KalFitAlg::start_seed(), KalFitTrack::update_forMdc(), and KalFitTrack::update_last().

                    {
    return m_Ea;
}

void 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 722 of file Helix.cxx.

References Helix::m_Ea, and Helix::m_matrixValid.

Referenced by KalFitTrack::chi2_next(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), KalFitTrack::order_wirhit(), KalFitTrack::pivot_numf(), KalFitAlg::smoother_anal(), and KalFitAlg::smoother_calib().

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

double Helix::kappa

(

void

)

const [inline]

Definition at line 230 of file Helix.h.

References Helix::m_ac.

Referenced by approach(), KalFitTrack::chi2_next(), KalFitAlg::fillTds_back(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), KalFitTrack::ms(), KalFitTrack::msgasmdc(), KalFitTrack::order_hits(), KalFitTrack::pivot_numf(), KalFitAlg::smoother_anal(), KalFitAlg::smoother_calib(), and KalFitTrack::tof().

                       {
    return m_ac[2];
}

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

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

Definition at line 277 of file Helix.cxx.

References cos(), Helix::del4MXDelA(), Helix::m_ac, Helix::m_cp, Helix::m_Ea, Helix::m_matrixValid, Helix::m_pivot, Helix::m_pt, Helix::m_r, Helix::m_sp, Helix::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);

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

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

Definition at line 252 of file Helix.cxx.

References cos(), Helix::del4MDelA(), Helix::m_ac, Helix::m_Ea, Helix::m_matrixValid, Helix::m_pt, Helix::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 Helix::momentum	(	double	dPhi,
		double	mass
	)			const

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

Definition at line 229 of file Helix.cxx.

References cos(), Helix::m_ac, Helix::m_pt, Helix::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 Helix::momentum	(	double	dPhi,
		HepSymMatrix &	Em
	)			const

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 206 of file Helix.cxx.

References cos(), Helix::delMDelA(), Helix::m_ac, Helix::m_Ea, Helix::m_matrixValid, Helix::m_pt, Helix::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 Helix::momentum

(

double

dPhi = 0.

)

const

returns momentum vector after rotating angle dPhi in phi direction.

Definition at line 186 of file Helix.cxx.

References cos(), Helix::m_ac, Helix::m_pt, Helix::pt(), and sin().

Referenced by KalFitTrack::chi2_next(), KalFitAlg::complete_track(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), KalFitAlg::smoother_anal(), and KalFitAlg::smoother_calib().

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

Helix & Helix::operator=

(

const Helix &

)

Copy operator.

Definition at line 386 of file Helix.cxx.

References genRecEmupikp::i, Helix::m_a, Helix::m_ac, Helix::m_alpha, Helix::m_bField, Helix::m_center, Helix::m_cp, Helix::m_Ea, Helix::m_matrixValid, Helix::m_pivot, Helix::m_pt, Helix::m_r, and Helix::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 Helix::phi0

(

void

)

const [inline]

Definition at line 224 of file Helix.h.

References Helix::m_ac.

Referenced by approach(), KalFitTrack::chi2_next(), KalFitAlg::fillTds_back(), KalFitTrack::intersect_cylinder(), KalFitTrack::pivot_numf(), KalFitTrack::radius_numf(), and KalFitAlg::smoother_anal().

                      {
    return m_ac[1];
}

const HepPoint3D & Helix::pivot

(

const HepPoint3D &

newPivot

)

sets pivot position.

Definition at line 310 of file Helix.cxx.

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

                                        {

    //std::cout<<" in Helix::pivot:"<<std::endl;
    //std::cout<<" m_alpha: "<<m_alpha<<std::endl;
    
    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 & Helix::pivot

(

void

)

const [inline]

returns pivot position.

Definition at line 200 of file Helix.h.

References Helix::m_pivot.

Referenced by approach(), KalFitTrack::chi2_next(), KalFitAlg::complete_track(), KalFitAlg::fillTds(), KalFitAlg::fillTds_back(), KalFitAlg::fillTds_ip(), KalFitAlg::fillTds_lead(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), KalFitTrack::intersect_xy_plane(), KalFitAlg::kalman_fitting_anal(), KalFitAlg::kalman_fitting_calib(), KalFitAlg::kalman_fitting_csmalign(), KalFitAlg::kalman_fitting_MdcxReco_Csmc_Sew(), KalFitTrack::order_wirhit(), KalFitTrack::pivot_numf(), KalFitTrack::radius_numf(), KalFitAlg::smoother_anal(), KalFitAlg::smoother_calib(), KalFitAlg::start_seed(), KalFitTrack::update_forMdc(), and KalFitTrack::update_last().

                       {
    return m_pivot;
}

double Helix::radius

(

void

)

const [inline]

returns radious of helix.

Definition at line 206 of file Helix.h.

References Helix::m_r.

Referenced by KalFitTrack::chi2_next(), KalFitTrack::eloss(), KalFitAlg::fillTds_back(), KalFitCylinder::intersect(), KalFitTrack::intersect_cylinder(), KalFitTrack::intersect_xy_plane(), KalFitTrack::intersect_yz_plane(), KalFitTrack::intersect_zx_plane(), KalFitTrack::pivot_numf(), and KalFitAlg::smoother_anal().

                        {
    return m_r;
}

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

sets helix pivot position, parameters, and error matrix.

Definition at line 375 of file Helix.cxx.

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

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

double Helix::sinPhi0

(

void

)

const [inline]

Definition at line 306 of file Helix.h.

References Helix::m_sp.

                         {
    return m_sp;
}

double Helix::tanl

(

void

)

const [inline]

Definition at line 242 of file Helix.h.

References Helix::m_ac.

Referenced by approach(), KalFitTrack::chi2_next(), KalFitAlg::fillTds_back(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), KalFitCylinder::intersect(), KalFitTrack::intersect_xy_plane(), KalFitTrack::ms(), KalFitTrack::msgasmdc(), KalFitTrack::pivot_numf(), KalFitAlg::smoother_anal(), KalFitAlg::smoother_calib(), and KalFitTrack::tof().

                      {
    return m_ac[4];
}

void Helix::updateCache

(

void

)

[private]

Definition at line 411 of file Helix.cxx.

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

Referenced by Helix().

                       {
    //
    //   Calculate Helix center( xc, yc ).
    //   
    //   xc = x0 + (dr + (alpha / kappa)) * cos(phi0)  (cm)
    //   yc = y0 + (dr + (alpha / kappa)) * sin(phi0)  (cm)
    //

    //std::cout<<" in updateCache, m_alpha: "<<m_alpha<<std::endl;

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

returns position and convariance matrix(Ex) after rotation.

Definition at line 165 of file Helix.cxx.

References cos(), Helix::delXDelA(), Helix::m_ac, Helix::m_cp, Helix::m_Ea, Helix::m_matrixValid, Helix::m_pivot, Helix::m_r, Helix::m_sp, sin(), and Helix::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 * Helix::x	(	double	dPhi,
		double	p[3]
	)			const

Definition at line 148 of file Helix.cxx.

References cos(), Helix::m_ac, Helix::m_cp, Helix::m_pivot, Helix::m_r, Helix::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 Helix::x

(

double

dPhi = 0.

)

const

returns position after rotating angle dPhi in phi direction.

Definition at line 131 of file Helix.cxx.

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

Referenced by approach(), KalFitTrack::chi2_next(), KalFitAlg::complete_track(), KalFitAlg::fillTds_back(), KalFitAlg::filter_fwd_anal(), KalFitAlg::filter_fwd_calib(), KalFitTrack::getDriftTime(), KalFitCylinder::intersect(), KalFitAlg::kalman_fitting_anal(), KalFitAlg::kalman_fitting_calib(), KalFitAlg::kalman_fitting_csmalign(), KalFitAlg::kalman_fitting_MdcxReco_Csmc_Sew(), KalFitTrack::order_wirhit(), KalFitTrack::pivot_numf(), KalFitTrack::radius_numf(), KalFitAlg::smoother_anal(), and KalFitAlg::smoother_calib().

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

const double Helix::ConstantAlpha = 333.564095 [static]

Constant alpha for uniform field.

Definition at line 162 of file Helix.h.

Referenced by approach().

HepVector KalmanFit::Helix::m_a [private]

Definition at line 168 of file Helix.h.

Referenced by Helix().

double KalmanFit::Helix::m_ac[5] [private]

Definition at line 178 of file Helix.h.

double KalmanFit::Helix::m_alpha [private]

Definition at line 166 of file Helix.h.

Referenced by Helix().

double KalmanFit::Helix::m_bField [private]

Definition at line 165 of file Helix.h.

Referenced by Helix().

HepPoint3D KalmanFit::Helix::m_center [private]

Definition at line 173 of file Helix.h.

double KalmanFit::Helix::m_cp [private]

Definition at line 174 of file Helix.h.

HepSymMatrix KalmanFit::Helix::m_Ea [private]

Definition at line 169 of file Helix.h.

bool KalmanFit::Helix::m_matrixValid [private]

Definition at line 170 of file Helix.h.

HepPoint3D KalmanFit::Helix::m_pivot [private]

Definition at line 167 of file Helix.h.

IMagneticFieldSvc* KalmanFit::Helix::m_pmgnIMF [private]

Definition at line 155 of file Helix.h.

Referenced by Helix().

double KalmanFit::Helix::m_pt [private]

Definition at line 176 of file Helix.h.

double KalmanFit::Helix::m_r [private]

Definition at line 177 of file Helix.h.

double KalmanFit::Helix::m_sp [private]

Definition at line 175 of file Helix.h.

---