KalmanFit Namespace Reference

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

Functions
std::ostream &	operator<< (std::ostream &o, const zav &z)
int	intersect (const Lpar &lp1, const Lpar &lp2, HepVector &v1, HepVector &v2)
std::ostream &	operator<< (std::ostream &o, Lpar &s)
float	prob_ (float *, int *)
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 256 of file KalFitAlg/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 640 of file KalFitAlg/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/3]

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

Definition at line 235 of file KalFitAlg/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/3]

std::ostream & KalmanFit::operator<< ( std::ostream & o, const zav & z )

inline

Definition at line 140 of file InstallArea/x86_64-el9-gcc13-dbg/include/KalFitAlg/lpav/zav.h.

                                                               {
    o << " zav::w=" << z._w << " sav=" << z._sav << " zav=" << z._zav << " nc=" << z._nc
      << " chisq=" << z._chisq << " a=" << z._a << " b=" << z._b << " c11=" << z._c11
      << " c21=" << z._c21 << " c22=" << z._c22 << " sig_inv=" << z._sig_inv << std::endl;
    return o;
  }

operator<<() [3/3]

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

Definition at line 340 of file KalFitAlg/src/lpav/Lpar.cxx.

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

prob_()

float KalmanFit::prob_	(	float *	,
		int *	)

Referenced by KalmanFit::Lpav::prob().