KalmanFit::Lpar Class Reference

#include <Lpar.h>

Inheritance diagram for KalmanFit::Lpar:

Public Member Functions
	Lpar ()
virtual	~Lpar ()
const Lpar &	operator= (const Lpar &)
void	neg ()
void	circle (double x1, double y1, double x2, double y2, double x3, double y3)
double	kappa () const
double	radius () const
HepVector	center () const
double	s (double x, double y) const
double	d (double x, double y) const
double	dr (double x, double y) const
double	s (double r, int dir=0) const
double	phi (double r, int dir=0) const
int	sd (double r, double x, double y, double limit, double &s, double &d) const
HepVector	Hpar (const HepPoint3D &pivot) const

Friends
class	Lpav
class	Lpar::Cpar
std::ostream &	operator<< (std::ostream &o, Lpar &s)
int	intersect (const Lpar &lp1, const Lpar &lp2, HepVector &v1, HepVector &v2)

Detailed Description

Definition at line 42 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

Constructor & Destructor Documentation

Lpar()

Lpar::Lpar ( )

inline

Definition at line 155 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

                  {
  m_alpha = 0;
  m_beta = 1;
  m_gamma = 0;
  m_kappa = 0;
}

~Lpar()

Lpar::~Lpar ( )

virtual

Definition at line 56 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx.

{
}

Member Function Documentation

center()

HepVector Lpar::center

(

)

const

Definition at line 232 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx.

{
#else
{
  HepVector v(3);
#endif
  v(1) = xc();
  v(2) = yc();
  v(3) = 0;
  return(v);
}

Referenced by KalFitWire::z().

circle()

void Lpar::circle	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x3,
		double	y3 )

Definition at line 81 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx.

                                {
  double a;
  double b;
  double c;
  double delta = (x1-x2)*(y1-y3) - (y1-y2)*(x1-x3);
  if(delta==0) {
    //
    // three points are on a line.
    //
    m_kappa = 0;
    double r12sq = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);
    if (r12sq>0) {
      double r12 = sqrt(r12sq);
      m_beta = -(x1-x2)/r12;
      m_alpha = (y1-y2)/r12;
      m_gamma = - (m_alpha*x1+m_beta*y1);
    } else {
      double r13sq = (x1-x3)*(x1-x3) + (y1-y3)*(y1-y3);
      if (r13sq>0) {
    double r13 = sqrt(r13sq);
    m_beta = -(x1-x3)/r13;
    m_alpha = (y1-y3)/r13;
    m_gamma = - (m_alpha*x3+m_beta*y3);
      } else {
    double r23sq = (x2-x3)*(x2-x3) + (y2-y3)*(y2-y3);
    if (r23sq>0) {
      double r23 = sqrt(r23sq);
      m_beta = -(x2-x3)/r23;
      m_alpha = (y2-y3)/r23;
      m_gamma = - (m_alpha*x3+m_beta*y3);
    } else {
      m_alpha = 1;
      m_beta = 0;
      m_gamma = 0;
    }
      }
    }
  } else {
    double r1sq = x1 * x1 + y1 * y1;
    double r2sq = x2 * x2 + y2 * y2;
    double r3sq = x3 * x3 + y3 * y3;
    a = 0.5 * (  (y1-y3)*(r1sq-r2sq) - (y1-y2)*(r1sq-r3sq)) / delta;
    b = 0.5 * (- (x1-x3)*(r1sq-r2sq) + (x1-x2)*(r1sq-r3sq)) / delta;
    double csq = (x1-a)*(x1-a) + (y1-b)*(y1-b);
    c = sqrt(csq);
    double csq2 = (x2-a)*(x2-a) + (y2-b)*(y2-b);
    double csq3 = (x3-a)*(x3-a) + (y3-b)*(y3-b);
    m_kappa = 1 / (2 * c);
    m_alpha = - 2 * a * m_kappa;
    m_beta = - 2 * b * m_kappa;
    m_gamma = (a*a + b*b - c*c) * m_kappa;
  }
}

d()

double Lpar::d ( double x, double y ) const

inline

Definition at line 207 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

                                              {
  double dd = d0(x,y);
  const double approx_limit = 0.2;
  if(std::fabs(m_kappa*dd)>approx_limit) return -1;
  return dd * ( 1 - m_kappa * dd );
}

Referenced by KalmanFit::Lpav::delta_chisq(), and sd().

dr()

double Lpar::dr ( double x, double y ) const

inline

Definition at line 214 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

                                               {
  double dx = xc() - x;
  double dy = yc() - y;
  double r = 0.5/std::fabs(m_kappa);
  return std::fabs(std::sqrt(dx * dx + dy * dy) - r);
}

Hpar()

HepVector Lpar::Hpar ( const HepPoint3D & pivot ) const

inline

Definition at line 268 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

                                                         {
  HepVector a(5);
  double dd = d0(pivot.x(),pivot.y());
  a(1) = dd * ( m_kappa * dd - 1 );
  a(2) = (m_kappa>0) ? std::atan2(yc() - pivot.y(), xc() - pivot.x()) + M_PI 
    : std::atan2(pivot.y() - yc(), pivot.x() - xc()) - M_PI;
  a(3) = -2.0*BELLE_ALPHA*m_kappa;
  a(4) = 0;
  a(5) = 0;
  return a;
}

kappa()

double KalmanFit::Lpar::kappa ( ) const

inline

Definition at line 63 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

{ return m_kappa; }

Referenced by s(), and s().

neg()

void Lpar::neg ( )

inline

Definition at line 196 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

                      {
  m_alpha = -m_alpha;
  m_beta = -m_beta;
  m_gamma = -m_gamma;
  m_kappa = -m_kappa;
}

Referenced by KalmanFit::Lpav::calculate_lpar(), and KalmanFit::Lpav::calculate_lpar3().

operator=()

const Lpar & Lpar::operator= ( const Lpar & l )

inline

Definition at line 169 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

                                              {
    if (this != &l) {
    m_alpha = l.m_alpha;
    m_beta = l.m_beta;
    m_gamma = l.m_gamma;
    m_kappa = l.m_kappa;
    }
  return *this;
}

Referenced by KalmanFit::Lpav::operator=().

phi()

double Lpar::phi	(	double	r,
		int	dir = 0 ) const

Definition at line 191 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx.

                                       {
  double x, y;
  if (!xy(r,x,y, dir)) return -1;
  double p = atan2(y,x);
  if (p<0) p += (2*M_PI);
  return p;
}

Referenced by KalmanFit::Lpav::extrapolate(), and sd().

radius()

double KalmanFit::Lpar::radius ( ) const

inline

Definition at line 64 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

{ return 0.5/std::fabs(m_kappa);}

Referenced by KalFitWire::z().

s() [1/2]

double Lpar::s	(	double	r,
		int	dir = 0 ) const

Definition at line 223 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx.

                                      {
  double d0 = da();
  if (fabs(r)<fabs(d0)) return -1;
  double b = fabs(kappa()) * sqrt((r*r-d0*d0)/(1 + 2 * kappa() * d0));
  if (fabs(b)>1) return -1;
  if(dir==0)return asin(b)/fabs(kappa());
  return (M_PI-asin(b))/fabs(kappa());
}

s() [2/2]

double Lpar::s	(	double	x,
		double	y ) const

Definition at line 211 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx.

                                       {
  double xh, yh, xx, yy;
  xhyh(x, y, xh, yh);
  double fk = fabs(kappa());
  if (fk==0) return 0;
  yy = 2 * fk * ( alpha() * yh - beta() * xh);
  xx = 2 * kappa() * ( alpha() * xh + beta() * yh ) + xi2();
  double sp = atan2(yy, xx);
  if (sp<0) sp += (2*M_PI);
  return sp / 2 / fk;
}

sd()

int Lpar::sd ( double r, double x, double y, double limit, double & s, double & d ) const

inline

Definition at line 248 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

                                                       {
  if ((x*yc()-y*xc())*m_kappa<0) return 0;
  double dd = d0(x,y);
  d = dd * ( 1 - m_kappa * dd );
  double d_cross_limit = d*limit;
  if (d_cross_limit < 0 || d_cross_limit > limit*limit) return 0;
  
  double rc = std::sqrt(m_alpha*m_alpha+m_beta*m_beta)/(2*m_kappa);
  double rho = 1./(-2*m_kappa);
  double cosPhi = (rc*rc + rho*rho - r*r)/(-2*rc*rho);
  double phi = std::acos(cosPhi);
  s = std::fabs(rho)*phi;
  d *= r/(std::fabs(rc)*std::sin(phi));
  if (abs(d) > abs(limit)) return 0;
  d_cross_limit = d*limit;
  if (d_cross_limit > limit*limit) return 0;
  return 1;
}

Friends And Related Symbol Documentation

intersect

int intersect ( const Lpar & lp1, const Lpar & lp2, HepVector & v1, HepVector & v2 )

friend

Definition at line 246 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx.

                                                                          {
  HepVector cen1(lp1.center());
  HepVector cen2(lp2.center());
  double dx = cen1(1)-cen2(1);
  double dy = cen1(2)-cen2(2);
  double dc = sqrt(dx*dx+dy*dy);
  if(dc<fabs(0.5/lp1.kappa())+fabs(0.5/lp2.kappa())) {
    double a1 = std::sqrt(lp1.alpha()) + std::sqrt(lp1.beta());
    double a2 = std::sqrt(lp2.alpha()) + std::sqrt(lp2.beta());
    double a3 = lp1.alpha()*lp2.alpha() + lp1.beta()*lp2.beta();
    double det = lp1.alpha()*lp2.beta() - lp1.beta()*lp2.alpha();
    if(fabs(det)>1e-12) {
      double c1 = a2 * std::sqrt(lp1.kappa()) + a1 * std::sqrt(lp2.kappa()) -
        2.0 * a3 * lp1.kappa() * lp2.kappa();
      if(c1!=0) {
        double cinv = 1.0 / c1;
        double c2 = std::sqrt(a3) - 0.5 * (a1 + a2) - 2.0 * a3 *
          (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
        double c3 = a2 * std::sqrt(lp1.gamma()) + a1 * std::sqrt(lp2.gamma()) -
          2.0 * a3 * lp1.gamma() * lp2.gamma();
        double root = std::sqrt(c2) - 4.0 * c1 * c3;
        if (root>=0) {
          root = sqrt(root);
          double rad2[2];
          rad2[0] = 0.5 * cinv * (-c2 - root);
          rad2[1] = 0.5 * cinv * (-c2 + root);
          double ab1 = -(lp2.beta() * lp1.gamma() - lp1.beta() * lp2.gamma());
          double ab2 = (lp2.alpha() * lp1.gamma() - lp1.alpha() * lp2.gamma());
          double ac1 = -(lp2.beta() * lp1.kappa() - lp1.beta() * lp2.kappa());
          double ac2 = (lp2.alpha() * lp1.kappa() - lp1.alpha() * lp2.kappa());
          double dinv = 1.0 / det;
          v1(1) = dinv * (ab1 + ac1 * rad2[0]);
          v1(2) = dinv * (ab2 + ac2 * rad2[0]);
          v1(3) = 0;
          v2(1) = dinv * (ab1 + ac1 * rad2[1]);
          v2(2) = dinv * (ab2 + ac2 * rad2[1]);
          v2(3) = 0;
      double d1 = lp1.d(v1(1),v1(2));
      double d2 = lp2.d(v1(1),v1(2));
      double d3 = lp1.d(v2(1),v2(2));
      double d4 = lp2.d(v2(1),v2(2));
          double r = sqrt(rad2[0]);
          Lpar::Cpar cp1(lp1);
          Lpar::Cpar cp2(lp2);
      for(int j=0;j<2;j++) {
        double s1,s2;
        if(j==0) {
          s1 = lp1.s(v1(1),v1(2));
          s2 = lp2.s(v1(1),v1(2));
        } else {
          s1 = lp1.s(v2(1),v2(2));
          s2 = lp2.s(v2(1),v2(2));
        }
        double phi1 = cp1.fi() + 2 * cp1.cu() * s1;
        double phi2 = cp2.fi() + 2 * cp2.cu() * s2;
        double f = (1 + 2 * cp1.cu() * cp1.da()) *
          (1 + 2 * cp2.cu() * cp2.da()) * cos(cp1.fi()-cp2.fi());
        f -= 2 * (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
        double cosphi12 = f;
      }
      return 2;
        }
      }
    }
  }
  return 0;
}

Lpar::Cpar

friend class Lpar::Cpar

friend

Definition at line 105 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

Lpav

friend class Lpav

friend

Definition at line 78 of file KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h.

operator<<

std::ostream & operator<< ( std::ostream & o, Lpar & s )

friend

Definition at line 322 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx.

                                               {
  return o << " al=" << s.m_alpha << " be=" << s.m_beta
           << " ka=" << s.m_kappa << " ga=" << s.m_gamma;
}

---

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

• KalFitAlg/KalFitAlg-00-15-20/KalFitAlg/lpav/Lpar.h
• KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpar.cxx