Lpar.cxx File Reference

#include <iostream>
#include <cmath>
#include "TrackUtil/Lpar.h"

Go to the source code of this file.

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

Function Documentation

intersect()

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

Definition at line 255 of file TrackUtil/src/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<<()

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

Definition at line 339 of file TrackUtil/src/Lpar.cxx.

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