KalmanFit Namespace Reference

Classes
class	Helix
	Helix parameter class. More...
class	Lpar
class	Lpav

Functions
int	intersect (const Lpar &lp1, const Lpar &lp2, HepVector &v1, HepVector &v2)
std::ostream &	operator<< (std::ostream &o, Lpar &s)
std::ostream &	operator<< (std::ostream &o, const Lpav &a)
Lpav	operator+ (const Lpav &la1, const Lpav &la2)

Function Documentation

intersect()

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

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

operator+()

Lpav KalmanFit::operator+	(	const Lpav &	la1,
		const Lpav &	la2 )

Definition at line 630 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpav.cxx.

{
#else
{
  Lpav la;
#endif
  la.m_wsum = la1.m_wsum + la2.m_wsum;
  la.m_xsum = la1.m_xsum + la2.m_xsum;
  la.m_ysum = la1.m_ysum + la2.m_ysum;
  la.m_xxsum = la1.m_xxsum + la2.m_xxsum;
  la.m_yysum = la1.m_yysum + la2.m_yysum;
  la.m_xysum = la1.m_xysum + la2.m_xysum;
  la.m_xrrsum = la1.m_xrrsum + la2.m_xrrsum;
  la.m_yrrsum = la1.m_yrrsum + la2.m_yrrsum;
  la.m_rrrrsum = la1.m_rrrrsum + la2.m_rrrrsum;
  la.m_nc = la1.m_nc + la2.m_nc;
  return la;
}

operator<<() [1/2]

std::ostream & KalmanFit::operator<<	(	std::ostream &	o,
		const Lpav &	a )

Definition at line 241 of file KalFitAlg/KalFitAlg-00-15-20/src/lpav/Lpav.cxx.

                                                     {
//  o << "wsum=" << a.m_wsum << " xsum=" << a.m_xsum << " ysum=" << a.m_ysum 
//  << " xxsum=" << a.m_xxsum << " xysum=" << a.m_xysum
//  << " yysum=" << a.m_yysum 
//  << " xrrsum=" << a.m_xrrsum << " yrrsum=" << a.m_yrrsum
//  << " rrrrsum=" << a.m_rrrrsum;
//  o << " rscale=" << a.m_rscale
//  << " xxavp=" << a.m_xxavp << " yyavp=" << a.m_yyavp
//  << " xrravp=" << a.m_xrravp << " yrravp=" << a.m_yrravp
//  << " rrrravp=" << a.m_rrrravp << " cosrot=" << a.m_cosrot
//  << " sinrot=" << a.m_sinrot
//  << endl;
  o << " nc=" << a.m_nc << " chisq=" << a.m_chisq << " " << (Lpar&) a;
  return o;
}

operator<<() [2/2]

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

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