Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

Lpar Class Reference

#include <Lpar.h>

Inheritance diagram for Lpar:

Lpav Lpav Lpav Lpav List of all members.

Public Member Functions

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

Private Member Functions

double alpha () const
double alpha () const
double alpha () const
double alpha () const
double arcfun (double xh, double yh) const
double arcfun (double xh, double yh) const
double arcfun (double xh, double yh) const
double arcfun (double xh, double yh) const
double beta () const
double beta () const
double beta () const
double beta () const
double check () const
double check () const
double check () const
double check () const
double d0 (double x, double y) const
double d0 (double x, double y) const
double d0 (double x, double y) const
double d0 (double x, double y) const
double da () const
double da () const
double da () const
double da () const
HepMatrix dldc () const
HepMatrix dldc () const
HepMatrix dldc () const
HepMatrix dldc () const
double gamma () const
double gamma () const
double gamma () const
double gamma () const
double kr2g (double r) const
double kr2g (double r) const
double kr2g (double r) const
double kr2g (double r) const
 Lpar (const Lpar &)
 Lpar (const Lpar &)
 Lpar (const Lpar &)
 Lpar (const Lpar &)
void move (double x, double y)
void move (double x, double y)
void move (double x, double y)
void move (double x, double y)
bool operator!= (const Lpar &) const
bool operator!= (const Lpar &) const
bool operator!= (const Lpar &) const
bool operator!= (const Lpar &) const
bool operator== (const Lpar &) const
bool operator== (const Lpar &) const
bool operator== (const Lpar &) const
bool operator== (const Lpar &) const
double r_max () const
double r_max () const
double r_max () const
double r_max () const
void rotate (double c, double s)
void rotate (double c, double s)
void rotate (double c, double s)
void rotate (double c, double s)
void scale (double s)
void scale (double s)
void scale (double s)
void scale (double s)
double x (double r) const
double x (double r) const
double x (double r) const
double x (double r) const
double xc () const
double xc () const
double xc () const
double xc () const
void xhyh (double x, double y, double &xh, double &yh) const
void xhyh (double x, double y, double &xh, double &yh) const
void xhyh (double x, double y, double &xh, double &yh) const
void xhyh (double x, double y, double &xh, double &yh) const
double xi2 () const
double xi2 () const
double xi2 () const
double xi2 () const
bool xy (double, double &, double &, int dir=0) const
bool xy (double, double &, double &, int dir=0) const
bool xy (double, double &, double &, int dir=0) const
bool xy (double, double &, double &, int dir=0) const
double y (double r) const
double y (double r) const
double y (double r) const
double y (double r) const
double yc () const
double yc () const
double yc () const
double yc () const

Private Attributes

double m_alpha
double m_beta
double m_gamma
double m_kappa
IMagneticFieldSvc * m_pmgnIMF
IMagneticFieldSvc * m_pmgnIMF

Static Private Attributes

const double BELLE_ALPHA

Friends

int intersect (const Lpar &, const Lpar &, HepVector &, HepVector &)
int intersect (const Lpar &, const Lpar &, HepVector &, HepVector &)
int intersect (const Lpar &, const Lpar &, HepVector &, HepVector &)
int intersect (const Lpar &, const Lpar &, HepVector &, HepVector &)
class Lpar::Cpar
class Lpav
std::ostream & operator<< (std::ostream &o, Lpar &)
std::ostream & operator<< (std::ostream &o, Lpar &)
std::ostream & operator<< (std::ostream &o, Lpar &)
std::ostream & operator<< (std::ostream &o, Lpar &)

Constructor & Destructor Documentation

Lpar::Lpar (   )  [inline]
  

00156                   {
00157   m_alpha = 0;
00158   m_beta = 1;
00159   m_gamma = 0;
00160   m_kappa = 0;
00161 }

Lpar::~Lpar (   )  [virtual]
  

00053 {
00054 }

Lpar::Lpar (  const Lpar &   )  [inline, private]
  

00163                               {
00164   m_alpha = l.m_alpha;
00165   m_beta = l.m_beta;
00166   m_gamma = l.m_gamma;
00167   m_kappa = l.m_kappa;
00168 }

Lpar::Lpar (   ) 
 

virtual Lpar::~Lpar (   )  [virtual]
 

Lpar::Lpar (  const Lpar &   )  [inline, private]
 

Lpar::Lpar (   ) 
 

virtual Lpar::~Lpar (   )  [virtual]
 

Lpar::Lpar (  const Lpar &   )  [inline, private]
 

Lpar::Lpar (   ) 
 

virtual Lpar::~Lpar (   )  [virtual]
 

Lpar::Lpar (  const Lpar &   )  [inline, private]
 

Member Function Documentation

double Lpar::alpha (  void   )  const [inline, private]
  

00127 { return m_alpha; }

double Lpar::alpha (  void   )  const [inline, private]
  

00119 { return m_alpha; }

double Lpar::alpha (  void   )  const [inline, private]
  

00127 { return m_alpha; }

double Lpar::alpha (  void   )  const [inline, private]
  

00119 { return m_alpha; }

double Lpar::arcfun (  double  xh,
double  yh
)  const [inline, private]
 

double Lpar::arcfun (  double  xh,
double  yh
)  const [inline, private]
 

double Lpar::arcfun (  double  xh,
double  yh
)  const [inline, private]
 

double Lpar::arcfun (  double  xh,
double  yh
)  const [inline, private]
  

00228                                                      {
00229   //
00230   // Duet way of calculating Sperp.
00231   //
00232   double r2kap = 2.0 * m_kappa;
00233   double xi = std::sqrt(xi2());
00234   double xinv = 1.0 / xi;
00235   double ar2kap = std::fabs(r2kap);
00236   double cross = m_alpha * yh - m_beta * xh;
00237   double a1 = ar2kap * cross * xinv;
00238   double a2 = r2kap * (m_alpha * xh + m_beta * yh) * xinv + xi;
00239   if (a1>=0 && a2>0 && a1<0.3) {
00240     double arg2 = a1*a1;
00241     return cross * ( 1.0 + arg2 * (1./6. + arg2 * (3./40.))) * xinv;
00242   } else {
00243     double at2 = std::atan2(a1,a2);
00244     if (at2<0) at2 += (2*M_PI);
00245     return at2/ar2kap;
00246   }
00247 }

double Lpar::beta (   )  const [inline, private]
  

00128 { return m_beta; }

double Lpar::beta (   )  const [inline, private]
  

00120 { return m_beta; }

double Lpar::beta (   )  const [inline, private]
  

00128 { return m_beta; }

double Lpar::beta (   )  const [inline, private]
  

00120 { return m_beta; }

HepVector Lpar::center (   )  const
 

HepVector Lpar::center (   )  const
 

HepVector Lpar::center (   )  const
 

HepVector Lpar::center (   )  const
  

00231 {
00232 #else
00233 {
00234   HepVector v(3);
00235 #endif
00236   v(1) = xc();
00237   v(2) = yc();
00238   v(3) = 0;
00239   return(v);
00240 }

double Lpar::check (   )  const [inline, private]
 

double Lpar::check (   )  const [inline, private]
 

double Lpar::check (   )  const [inline, private]
 

double Lpar::check (   )  const [inline, private]
  

00193                                 {
00194   return m_alpha * m_alpha + m_beta * m_beta - 4 * m_kappa * m_gamma - 1;
00195 }

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

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

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

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

00078                                         {
00079   double a;
00080   double b;
00081   double c;
00082   double delta = (x1-x2)*(y1-y3) - (y1-y2)*(x1-x3);
00083   if(delta==0) {
00084     //
00085     // three points are on a line.
00086     //
00087     m_kappa = 0;
00088     double r12sq = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);
00089     if (r12sq>0) {
00090       double r12 = sqrt(r12sq);
00091       m_beta = -(x1-x2)/r12;
00092       m_alpha = (y1-y2)/r12;
00093       m_gamma = - (m_alpha*x1+m_beta*y1);
00094     } else {
00095       double r13sq = (x1-x3)*(x1-x3) + (y1-y3)*(y1-y3);
00096       if (r13sq>0) {
00097         double r13 = sqrt(r13sq);
00098         m_beta = -(x1-x3)/r13;
00099         m_alpha = (y1-y3)/r13;
00100         m_gamma = - (m_alpha*x3+m_beta*y3);
00101       } else {
00102         double r23sq = (x2-x3)*(x2-x3) + (y2-y3)*(y2-y3);
00103         if (r23sq>0) {
00104           double r23 = sqrt(r23sq);
00105           m_beta = -(x2-x3)/r23;
00106           m_alpha = (y2-y3)/r23;
00107           m_gamma = - (m_alpha*x3+m_beta*y3);
00108         } else {
00109           m_alpha = 1;
00110           m_beta = 0;
00111           m_gamma = 0;
00112         }
00113       }
00114     }
00115   } else {
00116     double r1sq = x1 * x1 + y1 * y1;
00117     double r2sq = x2 * x2 + y2 * y2;
00118     double r3sq = x3 * x3 + y3 * y3;
00119     a = 0.5 * (  (y1-y3)*(r1sq-r2sq) - (y1-y2)*(r1sq-r3sq)) / delta;
00120     b = 0.5 * (- (x1-x3)*(r1sq-r2sq) + (x1-x2)*(r1sq-r3sq)) / delta;
00121     double csq = (x1-a)*(x1-a) + (y1-b)*(y1-b);
00122     c = sqrt(csq);
00123     double csq2 = (x2-a)*(x2-a) + (y2-b)*(y2-b);
00124     double csq3 = (x3-a)*(x3-a) + (y3-b)*(y3-b);
00125     m_kappa = 1 / (2 * c);
00126     m_alpha = - 2 * a * m_kappa;
00127     m_beta = - 2 * b * m_kappa;
00128     m_gamma = (a*a + b*b - c*c) * m_kappa;
00129   }
00130 }

double Lpar::d (  double  x,
double  y
)  const [inline]
 

double Lpar::d (  double  x,
double  y
)  const [inline]
 

double Lpar::d (  double  x,
double  y
)  const [inline]
 

double Lpar::d (  double  x,
double  y
)  const [inline]
  

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

double Lpar::d0 (  double  x,
double  y
)  const [inline, private]
 

double Lpar::d0 (  double  x,
double  y
)  const [inline, private]
 

double Lpar::d0 (  double  x,
double  y
)  const [inline, private]
 

double Lpar::d0 (  double  x,
double  y
)  const [inline, private]
  

00204                                                {
00205   return m_alpha * x + m_beta * y + m_gamma + m_kappa * ( x * x + y * y);
00206 }

double Lpar::da (   )  const [inline, private]
  

00142 {  return 2 * gamma() / (std::sqrt(xi2()) + 1); }

double Lpar::da (   )  const [inline, private]
  

00134 {  return 2 * gamma() / (std::sqrt(xi2()) + 1); }

double Lpar::da (   )  const [inline, private]
  

00142 {  return 2 * gamma() / (std::sqrt(xi2()) + 1); }

double Lpar::da (   )  const [inline, private]
  

00134 {  return 2 * gamma() / (std::sqrt(xi2()) + 1); }

HepMatrix Lpar::dldc (   )  const [private]
 

HepMatrix Lpar::dldc (   )  const [private]
 

HepMatrix Lpar::dldc (   )  const [private]
 

HepMatrix Lpar::dldc (   )  const [private]
  

00135 {
00136 #else
00137 {
00138   HepMatrix vret(3,4);
00139 #endif
00140   Cpar cp(*this);
00141   double xi = cp.xi();
00142   double s = cp.sfi();
00143   double c = cp.cfi();
00144   vret(1,1) = 2*cp.da()*s;
00145   vret(1,2) = -2*cp.da()*c;
00146   vret(1,3) = cp.da()*cp.da();
00147   vret(1,4) = 1;
00148   vret(2,1) = xi*c;
00149   vret(2,2) = xi*s;
00150   vret(2,3) = 0;
00151   vret(2,4) = 0;
00152   vret(3,1) = 2*cp.cu()*s;
00153   vret(3,2) = -2*cp.cu()*c;
00154   vret(3,3) = xi;
00155   vret(3,4) = 0;
00156   return vret;
00157 }

double Lpar::dr (  double  x,
double  y
)  const [inline]
 

double Lpar::dr (  double  x,
double  y
)  const [inline]
 

double Lpar::dr (  double  x,
double  y
)  const [inline]
 

double Lpar::dr (  double  x,
double  y
)  const [inline]
  

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

double Lpar::gamma (   )  const [inline, private]
  

00129 { return m_gamma; }

double Lpar::gamma (   )  const [inline, private]
  

00121 { return m_gamma; }

double Lpar::gamma (   )  const [inline, private]
  

00129 { return m_gamma; }

double Lpar::gamma (   )  const [inline, private]
  

00121 { return m_gamma; }

HepVector Lpar::Hpar (  const HepPoint3D &  pivot  )  const [inline]
 

HepVector Lpar::Hpar (  const HepPoint3D &  pivot  )  const [inline]
 

HepVector Lpar::Hpar (  const HepPoint3D &  pivot  )  const [inline]
 

HepVector Lpar::Hpar (  const HepPoint3D &  pivot  )  const [inline]
  

00269                                                          {
00270   HepVector a(5);
00271   double dd = d0(pivot.x(),pivot.y());
00272   a(1) = dd * ( m_kappa * dd - 1 );
00273   a(2) = (m_kappa>0) ? std::atan2(yc() - pivot.y(), xc() - pivot.x()) + M_PI 
00274     : std::atan2(pivot.y() - yc(), pivot.x() - xc()) - M_PI;
00275   a(3) = -2.0*BELLE_ALPHA*m_kappa;
00276   a(4) = 0;
00277   a(5) = 0;
00278   return a;
00279 }

double Lpar::kappa (  void   )  const [inline]
  

00073 { return m_kappa; }

double Lpar::kappa (  void   )  const [inline]
  

00063 { return m_kappa; }

double Lpar::kappa (  void   )  const [inline]
  

00073 { return m_kappa; }

double Lpar::kappa (  void   )  const [inline]
  

00063 { return m_kappa; }

double Lpar::kr2g (  double  r  )  const [inline, private]
  

00133 { return m_kappa * r * r + m_gamma; }

double Lpar::kr2g (  double  r  )  const [inline, private]
  

00125 { return m_kappa * r * r + m_gamma; }

double Lpar::kr2g (  double  r  )  const [inline, private]
  

00133 { return m_kappa * r * r + m_gamma; }

double Lpar::kr2g (  double  r  )  const [inline, private]
  

00125 { return m_kappa * r * r + m_gamma; }

void Lpar::move (  double  x,
double  y
)  [inline, private]
 

void Lpar::move (  double  x,
double  y
)  [inline, private]
 

void Lpar::move (  double  x,
double  y
)  [inline, private]
 

void Lpar::move (  double  x,
double  y
)  [inline, private]
  

00187                                           {
00188   m_gamma += m_kappa * ( x * x + y * y ) + m_alpha * x + m_beta * y;
00189   m_alpha += 2 * m_kappa * x;
00190   m_beta  += 2 * m_kappa * y; 
00191 }

void Lpar::neg (   )  [inline]
 

void Lpar::neg (   )  [inline]
 

void Lpar::neg (   )  [inline]
 

void Lpar::neg (   )  [inline]
  

00197                       {
00198   m_alpha = -m_alpha;
00199   m_beta = -m_beta;
00200   m_gamma = -m_gamma;
00201   m_kappa = -m_kappa;
00202 }

bool Lpar::operator!= (  const Lpar &   )  const [private]
 

bool Lpar::operator!= (  const Lpar &   )  const [private]
 

bool Lpar::operator!= (  const Lpar &   )  const [private]
 

bool Lpar::operator!= (  const Lpar &   )  const [private]
 

const Lpar& Lpar::operator= (  const Lpar &   )  [inline]
 

Reimplemented in Lpav, Lpav, Lpav, and Lpav.

const Lpar& Lpar::operator= (  const Lpar &   )  [inline]
 

Reimplemented in Lpav, Lpav, Lpav, and Lpav.

const Lpar& Lpar::operator= (  const Lpar &   )  [inline]
 

Reimplemented in Lpav, Lpav, Lpav, and Lpav.

const Lpar & Lpar::operator= (  const Lpar &   )  [inline]
 

Reimplemented in Lpav, Lpav, Lpav, and Lpav.

00170                                               {
00171     if (this != &l) {
00172         m_alpha = l.m_alpha;
00173         m_beta = l.m_beta;
00174         m_gamma = l.m_gamma;
00175         m_kappa = l.m_kappa;
00176     }
00177   return *this;
00178 }

bool Lpar::operator== (  const Lpar &   )  const [private]
 

bool Lpar::operator== (  const Lpar &   )  const [private]
 

bool Lpar::operator== (  const Lpar &   )  const [private]
 

bool Lpar::operator== (  const Lpar &   )  const [private]
 

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

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

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

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

00187                                        {
00188   double x, y;
00189   if (!xy(r,x,y, dir)) return -1;
00190   double p = atan2(y,x);
00191   if (p<0) p += (2*M_PI);
00192   return p;
00193 }

double Lpar::r_max (   )  const [inline, private]
 

double Lpar::r_max (   )  const [inline, private]
 

double Lpar::r_max (   )  const [inline, private]
 

double Lpar::r_max (   )  const [inline, private]
  

00222                                 {
00223   if (m_kappa==0) return 100000000.0;
00224   if (m_gamma==0) return 1/std::fabs(m_kappa);
00225   return std::fabs(2*m_gamma/(std::sqrt(1+4*m_gamma*m_kappa)-1));
00226 }

double Lpar::radius (  void   )  const [inline]
  

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

double Lpar::radius (  void   )  const [inline]
  

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

double Lpar::radius (  void   )  const [inline]
  

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

double Lpar::radius (  void   )  const [inline]
  

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

void Lpar::rotate (  double  c,
double  s
)  [inline, private]
 

void Lpar::rotate (  double  c,
double  s
)  [inline, private]
 

void Lpar::rotate (  double  c,
double  s
)  [inline, private]
 

void Lpar::rotate (  double  c,
double  s
)  [inline, private]
  

00180                                            {
00181   double aLpar =  c * m_alpha + s * m_beta;
00182   double betar = -s * m_alpha + c * m_beta;
00183   m_alpha = aLpar;
00184   m_beta = betar;
00185 }

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

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

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

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

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

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

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

00219                                       {
00220   double d0 = da();
00221   if (fabs(r)<fabs(d0)) return -1;
00222   double b = fabs(kappa()) * sqrt((r*r-d0*d0)/(1 + 2 * kappa() * d0));
00223   if (fabs(b)>1) return -1;
00224   if(dir==0)return asin(b)/fabs(kappa());
00225   return (M_PI-asin(b))/fabs(kappa());
00226 }

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

00207                                        {
00208   double xh, yh, xx, yy;
00209   xhyh(x, y, xh, yh);
00210   double fk = fabs(kappa());
00211   if (fk==0) return 0;
00212   yy = 2 * fk * ( alpha() * yh - beta() * xh);
00213   xx = 2 * kappa() * ( alpha() * xh + beta() * yh ) + xi2();
00214   double sp = atan2(yy, xx);
00215   if (sp<0) sp += (2*M_PI);
00216   return sp / 2 / fk;
00217 }

void Lpar::scale (  double  s  )  [inline, private]
  

00122 { m_kappa /= s; m_gamma *= s; }

void Lpar::scale (  double  s  )  [inline, private]
  

00114 { m_kappa /= s; m_gamma *= s; }

void Lpar::scale (  double  s  )  [inline, private]
  

00122 { m_kappa /= s; m_gamma *= s; }

void Lpar::scale (  double  s  )  [inline, private]
  

00114 { m_kappa /= s; m_gamma *= s; }

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

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

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

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

00250                                                                {
00251   if ((x*yc()-y*xc())*m_kappa<0) return 0;
00252   double dd = d0(x,y);
00253   d = dd * ( 1 - m_kappa * dd );
00254   double d_cross_limit = d*limit;
00255   if (d_cross_limit < 0 || d_cross_limit > limit*limit) return 0;
00256   
00257   double rc = std::sqrt(m_alpha*m_alpha+m_beta*m_beta)/(2*m_kappa);
00258   double rho = 1./(-2*m_kappa);
00259   double cosPhi = (rc*rc + rho*rho - r*r)/(-2*rc*rho);
00260   double phi = std::acos(cosPhi);
00261   s = std::fabs(rho)*phi;
00262   d *= r/(std::fabs(rc)*std::sin(phi));
00263   if (abs(d) > abs(limit)) return 0;
00264   d_cross_limit = d*limit;
00265   if (d_cross_limit > limit*limit) return 0;
00266   return 1;
00267 }

double Lpar::x (  double  r  )  const [private]
 

double Lpar::x (  double  r  )  const [private]
 

double Lpar::x (  double  r  )  const [private]
 

double Lpar::x (  double  r  )  const [private]
  

00175                              {
00176   double t_x, t_y;
00177   xy(r, t_x, t_y);
00178   return t_x;
00179 }

double Lpar::xc (   )  const [inline, private]
  

00140 { return - m_alpha/2/m_kappa; }

double Lpar::xc (   )  const [inline, private]
  

00132 { return - m_alpha/2/m_kappa; }

double Lpar::xc (   )  const [inline, private]
  

00140 { return - m_alpha/2/m_kappa; }

double Lpar::xc (   )  const [inline, private]
  

00132 { return - m_alpha/2/m_kappa; }

void Lpar::xhyh (  double  x,
double  y,
double &  xh,
double &  yh
)  const [private]
 

void Lpar::xhyh (  double  x,
double  y,
double &  xh,
double &  yh
)  const [private]
 

void Lpar::xhyh (  double  x,
double  y,
double &  xh,
double &  yh
)  const [private]
 

void Lpar::xhyh (  double  x,
double  y,
double &  xh,
double &  yh
)  const [private]
  

00195                                                                 {
00196   double ddm = dr(x, y);
00197   if (ddm==0) {
00198     xh = x;
00199     yh = y;
00200     return;
00201   }
00202   double kdp1 = 1 + 2 * kappa() * ddm;
00203   xh = x - ddm * ( 2 * kappa() * x + alpha())/kdp1;
00204   yh = y - ddm * ( 2 * kappa() * y + beta())/kdp1;
00205 }

double Lpar::xi2 (   )  const [inline, private]
  

00137 { return 1 + 4 * m_kappa * m_gamma; }

double Lpar::xi2 (   )  const [inline, private]
  

00129 { return 1 + 4 * m_kappa * m_gamma; }

double Lpar::xi2 (   )  const [inline, private]
  

00137 { return 1 + 4 * m_kappa * m_gamma; }

double Lpar::xi2 (   )  const [inline, private]
  

00129 { return 1 + 4 * m_kappa * m_gamma; }

bool Lpar::xy (  double  ,
double &  ,
double &  ,
int  dir = 0
)  const [private]
 

bool Lpar::xy (  double  ,
double &  ,
double &  ,
int  dir = 0
)  const [private]
 

bool Lpar::xy (  double  ,
double &  ,
double &  ,
int  dir = 0
)  const [private]
 

bool Lpar::xy (  double  ,
double &  ,
double &  ,
int  dir = 0
)  const [private]
  

00159                                                            {
00160   double t_kr2g = kr2g(r);
00161   double t_xi2 = xi2();
00162   double ro = r * r * t_xi2 - t_kr2g * t_kr2g;
00163   if ( ro < 0  ) return false;
00164   double rs = sqrt(ro);
00165   if(dir==0) {
00166     x = (- m_alpha * t_kr2g  -  m_beta * rs) / t_xi2;
00167     y = (- m_beta  * t_kr2g  + m_alpha * rs) / t_xi2;
00168   } else {
00169     x = (- m_alpha * t_kr2g  +  m_beta * rs) / t_xi2;
00170     y = (- m_beta  * t_kr2g  - m_alpha * rs) / t_xi2;
00171   }
00172   return true;
00173 }

double Lpar::y (  double  r  )  const [private]
 

double Lpar::y (  double  r  )  const [private]
 

double Lpar::y (  double  r  )  const [private]
 

double Lpar::y (  double  r  )  const [private]
  

00181                              {
00182   double t_x, t_y;
00183   xy(r, t_x, t_y);
00184   return t_y;
00185 }

double Lpar::yc (   )  const [inline, private]
  

00141 { return - m_beta/2/m_kappa; }

double Lpar::yc (   )  const [inline, private]
  

00133 { return - m_beta/2/m_kappa; }

double Lpar::yc (   )  const [inline, private]
  

00141 { return - m_beta/2/m_kappa; }

double Lpar::yc (   )  const [inline, private]
  

00133 { return - m_beta/2/m_kappa; }

Friends And Related Function Documentation

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

00242                                                                           {
00243   HepVector cen1(lp1.center());
00244   HepVector cen2(lp2.center());
00245   double dx = cen1(1)-cen2(1);
00246   double dy = cen1(2)-cen2(2);
00247   double dc = sqrt(dx*dx+dy*dy);
00248   if(dc<fabs(0.5/lp1.kappa())+fabs(0.5/lp2.kappa())) {
00249     double a1 = std::sqrt(lp1.alpha()) + std::sqrt(lp1.beta());
00250     double a2 = std::sqrt(lp2.alpha()) + std::sqrt(lp2.beta());
00251     double a3 = lp1.alpha()*lp2.alpha() + lp1.beta()*lp2.beta();
00252     double det = lp1.alpha()*lp2.beta() - lp1.beta()*lp2.alpha();
00253     if(fabs(det)>1e-12) {
00254       double c1 = a2 * std::sqrt(lp1.kappa()) + a1 * std::sqrt(lp2.kappa()) -
00255         2.0 * a3 * lp1.kappa() * lp2.kappa();
00256       if(c1!=0) {
00257         double cinv = 1.0 / c1;
00258         double c2 = std::sqrt(a3) - 0.5 * (a1 + a2) - 2.0 * a3 *
00259           (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
00260         double c3 = a2 * std::sqrt(lp1.gamma()) + a1 * std::sqrt(lp2.gamma()) -
00261           2.0 * a3 * lp1.gamma() * lp2.gamma();
00262         double root = std::sqrt(c2) - 4.0 * c1 * c3;
00263         if (root>=0) {
00264           root = sqrt(root);
00265           double rad2[2];
00266           rad2[0] = 0.5 * cinv * (-c2 - root);
00267           rad2[1] = 0.5 * cinv * (-c2 + root);
00268           double ab1 = -(lp2.beta() * lp1.gamma() - lp1.beta() * lp2.gamma());
00269           double ab2 = (lp2.alpha() * lp1.gamma() - lp1.alpha() * lp2.gamma());
00270           double ac1 = -(lp2.beta() * lp1.kappa() - lp1.beta() * lp2.kappa());
00271           double ac2 = (lp2.alpha() * lp1.kappa() - lp1.alpha() * lp2.kappa());
00272           double dinv = 1.0 / det;
00273           v1(1) = dinv * (ab1 + ac1 * rad2[0]);
00274           v1(2) = dinv * (ab2 + ac2 * rad2[0]);
00275           v1(3) = 0;
00276           v2(1) = dinv * (ab1 + ac1 * rad2[1]);
00277           v2(2) = dinv * (ab2 + ac2 * rad2[1]);
00278           v2(3) = 0;
00279           double d1 = lp1.d(v1(1),v1(2));
00280           double d2 = lp2.d(v1(1),v1(2));
00281           double d3 = lp1.d(v2(1),v2(2));
00282           double d4 = lp2.d(v2(1),v2(2));
00283           double r = sqrt(rad2[0]);
00284           Lpar::Cpar cp1(lp1);
00285           Lpar::Cpar cp2(lp2);
00286           for(int j=0;j<2;j++) {
00287             double s1,s2;
00288             if(j==0) {
00289               s1 = lp1.s(v1(1),v1(2));
00290               s2 = lp2.s(v1(1),v1(2));
00291             } else {
00292               s1 = lp1.s(v2(1),v2(2));
00293               s2 = lp2.s(v2(1),v2(2));
00294             }
00295             double phi1 = cp1.fi() + 2 * cp1.cu() * s1;
00296             double phi2 = cp2.fi() + 2 * cp2.cu() * s2;
00297             double f = (1 + 2 * cp1.cu() * cp1.da()) *
00298               (1 + 2 * cp2.cu() * cp2.da()) * cos(cp1.fi()-cp2.fi());
00299             f -= 2 * (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
00300             double cosphi12 = f;
00301           }
00302           return 2;
00303         }
00304       }
00305     }
00306   }
00307   return 0;
00308 }

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

00242                                                                           {
00243   HepVector cen1(lp1.center());
00244   HepVector cen2(lp2.center());
00245   double dx = cen1(1)-cen2(1);
00246   double dy = cen1(2)-cen2(2);
00247   double dc = sqrt(dx*dx+dy*dy);
00248   if(dc<fabs(0.5/lp1.kappa())+fabs(0.5/lp2.kappa())) {
00249     double a1 = std::sqrt(lp1.alpha()) + std::sqrt(lp1.beta());
00250     double a2 = std::sqrt(lp2.alpha()) + std::sqrt(lp2.beta());
00251     double a3 = lp1.alpha()*lp2.alpha() + lp1.beta()*lp2.beta();
00252     double det = lp1.alpha()*lp2.beta() - lp1.beta()*lp2.alpha();
00253     if(fabs(det)>1e-12) {
00254       double c1 = a2 * std::sqrt(lp1.kappa()) + a1 * std::sqrt(lp2.kappa()) -
00255         2.0 * a3 * lp1.kappa() * lp2.kappa();
00256       if(c1!=0) {
00257         double cinv = 1.0 / c1;
00258         double c2 = std::sqrt(a3) - 0.5 * (a1 + a2) - 2.0 * a3 *
00259           (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
00260         double c3 = a2 * std::sqrt(lp1.gamma()) + a1 * std::sqrt(lp2.gamma()) -
00261           2.0 * a3 * lp1.gamma() * lp2.gamma();
00262         double root = std::sqrt(c2) - 4.0 * c1 * c3;
00263         if (root>=0) {
00264           root = sqrt(root);
00265           double rad2[2];
00266           rad2[0] = 0.5 * cinv * (-c2 - root);
00267           rad2[1] = 0.5 * cinv * (-c2 + root);
00268           double ab1 = -(lp2.beta() * lp1.gamma() - lp1.beta() * lp2.gamma());
00269           double ab2 = (lp2.alpha() * lp1.gamma() - lp1.alpha() * lp2.gamma());
00270           double ac1 = -(lp2.beta() * lp1.kappa() - lp1.beta() * lp2.kappa());
00271           double ac2 = (lp2.alpha() * lp1.kappa() - lp1.alpha() * lp2.kappa());
00272           double dinv = 1.0 / det;
00273           v1(1) = dinv * (ab1 + ac1 * rad2[0]);
00274           v1(2) = dinv * (ab2 + ac2 * rad2[0]);
00275           v1(3) = 0;
00276           v2(1) = dinv * (ab1 + ac1 * rad2[1]);
00277           v2(2) = dinv * (ab2 + ac2 * rad2[1]);
00278           v2(3) = 0;
00279           double d1 = lp1.d(v1(1),v1(2));
00280           double d2 = lp2.d(v1(1),v1(2));
00281           double d3 = lp1.d(v2(1),v2(2));
00282           double d4 = lp2.d(v2(1),v2(2));
00283           double r = sqrt(rad2[0]);
00284           Lpar::Cpar cp1(lp1);
00285           Lpar::Cpar cp2(lp2);
00286           for(int j=0;j<2;j++) {
00287             double s1,s2;
00288             if(j==0) {
00289               s1 = lp1.s(v1(1),v1(2));
00290               s2 = lp2.s(v1(1),v1(2));
00291             } else {
00292               s1 = lp1.s(v2(1),v2(2));
00293               s2 = lp2.s(v2(1),v2(2));
00294             }
00295             double phi1 = cp1.fi() + 2 * cp1.cu() * s1;
00296             double phi2 = cp2.fi() + 2 * cp2.cu() * s2;
00297             double f = (1 + 2 * cp1.cu() * cp1.da()) *
00298               (1 + 2 * cp2.cu() * cp2.da()) * cos(cp1.fi()-cp2.fi());
00299             f -= 2 * (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
00300             double cosphi12 = f;
00301           }
00302           return 2;
00303         }
00304       }
00305     }
00306   }
00307   return 0;
00308 }

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

00242                                                                           {
00243   HepVector cen1(lp1.center());
00244   HepVector cen2(lp2.center());
00245   double dx = cen1(1)-cen2(1);
00246   double dy = cen1(2)-cen2(2);
00247   double dc = sqrt(dx*dx+dy*dy);
00248   if(dc<fabs(0.5/lp1.kappa())+fabs(0.5/lp2.kappa())) {
00249     double a1 = std::sqrt(lp1.alpha()) + std::sqrt(lp1.beta());
00250     double a2 = std::sqrt(lp2.alpha()) + std::sqrt(lp2.beta());
00251     double a3 = lp1.alpha()*lp2.alpha() + lp1.beta()*lp2.beta();
00252     double det = lp1.alpha()*lp2.beta() - lp1.beta()*lp2.alpha();
00253     if(fabs(det)>1e-12) {
00254       double c1 = a2 * std::sqrt(lp1.kappa()) + a1 * std::sqrt(lp2.kappa()) -
00255         2.0 * a3 * lp1.kappa() * lp2.kappa();
00256       if(c1!=0) {
00257         double cinv = 1.0 / c1;
00258         double c2 = std::sqrt(a3) - 0.5 * (a1 + a2) - 2.0 * a3 *
00259           (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
00260         double c3 = a2 * std::sqrt(lp1.gamma()) + a1 * std::sqrt(lp2.gamma()) -
00261           2.0 * a3 * lp1.gamma() * lp2.gamma();
00262         double root = std::sqrt(c2) - 4.0 * c1 * c3;
00263         if (root>=0) {
00264           root = sqrt(root);
00265           double rad2[2];
00266           rad2[0] = 0.5 * cinv * (-c2 - root);
00267           rad2[1] = 0.5 * cinv * (-c2 + root);
00268           double ab1 = -(lp2.beta() * lp1.gamma() - lp1.beta() * lp2.gamma());
00269           double ab2 = (lp2.alpha() * lp1.gamma() - lp1.alpha() * lp2.gamma());
00270           double ac1 = -(lp2.beta() * lp1.kappa() - lp1.beta() * lp2.kappa());
00271           double ac2 = (lp2.alpha() * lp1.kappa() - lp1.alpha() * lp2.kappa());
00272           double dinv = 1.0 / det;
00273           v1(1) = dinv * (ab1 + ac1 * rad2[0]);
00274           v1(2) = dinv * (ab2 + ac2 * rad2[0]);
00275           v1(3) = 0;
00276           v2(1) = dinv * (ab1 + ac1 * rad2[1]);
00277           v2(2) = dinv * (ab2 + ac2 * rad2[1]);
00278           v2(3) = 0;
00279           double d1 = lp1.d(v1(1),v1(2));
00280           double d2 = lp2.d(v1(1),v1(2));
00281           double d3 = lp1.d(v2(1),v2(2));
00282           double d4 = lp2.d(v2(1),v2(2));
00283           double r = sqrt(rad2[0]);
00284           Lpar::Cpar cp1(lp1);
00285           Lpar::Cpar cp2(lp2);
00286           for(int j=0;j<2;j++) {
00287             double s1,s2;
00288             if(j==0) {
00289               s1 = lp1.s(v1(1),v1(2));
00290               s2 = lp2.s(v1(1),v1(2));
00291             } else {
00292               s1 = lp1.s(v2(1),v2(2));
00293               s2 = lp2.s(v2(1),v2(2));
00294             }
00295             double phi1 = cp1.fi() + 2 * cp1.cu() * s1;
00296             double phi2 = cp2.fi() + 2 * cp2.cu() * s2;
00297             double f = (1 + 2 * cp1.cu() * cp1.da()) *
00298               (1 + 2 * cp2.cu() * cp2.da()) * cos(cp1.fi()-cp2.fi());
00299             f -= 2 * (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
00300             double cosphi12 = f;
00301           }
00302           return 2;
00303         }
00304       }
00305     }
00306   }
00307   return 0;
00308 }

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

00242                                                                           {
00243   HepVector cen1(lp1.center());
00244   HepVector cen2(lp2.center());
00245   double dx = cen1(1)-cen2(1);
00246   double dy = cen1(2)-cen2(2);
00247   double dc = sqrt(dx*dx+dy*dy);
00248   if(dc<fabs(0.5/lp1.kappa())+fabs(0.5/lp2.kappa())) {
00249     double a1 = std::sqrt(lp1.alpha()) + std::sqrt(lp1.beta());
00250     double a2 = std::sqrt(lp2.alpha()) + std::sqrt(lp2.beta());
00251     double a3 = lp1.alpha()*lp2.alpha() + lp1.beta()*lp2.beta();
00252     double det = lp1.alpha()*lp2.beta() - lp1.beta()*lp2.alpha();
00253     if(fabs(det)>1e-12) {
00254       double c1 = a2 * std::sqrt(lp1.kappa()) + a1 * std::sqrt(lp2.kappa()) -
00255         2.0 * a3 * lp1.kappa() * lp2.kappa();
00256       if(c1!=0) {
00257         double cinv = 1.0 / c1;
00258         double c2 = std::sqrt(a3) - 0.5 * (a1 + a2) - 2.0 * a3 *
00259           (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
00260         double c3 = a2 * std::sqrt(lp1.gamma()) + a1 * std::sqrt(lp2.gamma()) -
00261           2.0 * a3 * lp1.gamma() * lp2.gamma();
00262         double root = std::sqrt(c2) - 4.0 * c1 * c3;
00263         if (root>=0) {
00264           root = sqrt(root);
00265           double rad2[2];
00266           rad2[0] = 0.5 * cinv * (-c2 - root);
00267           rad2[1] = 0.5 * cinv * (-c2 + root);
00268           double ab1 = -(lp2.beta() * lp1.gamma() - lp1.beta() * lp2.gamma());
00269           double ab2 = (lp2.alpha() * lp1.gamma() - lp1.alpha() * lp2.gamma());
00270           double ac1 = -(lp2.beta() * lp1.kappa() - lp1.beta() * lp2.kappa());
00271           double ac2 = (lp2.alpha() * lp1.kappa() - lp1.alpha() * lp2.kappa());
00272           double dinv = 1.0 / det;
00273           v1(1) = dinv * (ab1 + ac1 * rad2[0]);
00274           v1(2) = dinv * (ab2 + ac2 * rad2[0]);
00275           v1(3) = 0;
00276           v2(1) = dinv * (ab1 + ac1 * rad2[1]);
00277           v2(2) = dinv * (ab2 + ac2 * rad2[1]);
00278           v2(3) = 0;
00279           double d1 = lp1.d(v1(1),v1(2));
00280           double d2 = lp2.d(v1(1),v1(2));
00281           double d3 = lp1.d(v2(1),v2(2));
00282           double d4 = lp2.d(v2(1),v2(2));
00283           double r = sqrt(rad2[0]);
00284           Lpar::Cpar cp1(lp1);
00285           Lpar::Cpar cp2(lp2);
00286           for(int j=0;j<2;j++) {
00287             double s1,s2;
00288             if(j==0) {
00289               s1 = lp1.s(v1(1),v1(2));
00290               s2 = lp2.s(v1(1),v1(2));
00291             } else {
00292               s1 = lp1.s(v2(1),v2(2));
00293               s2 = lp2.s(v2(1),v2(2));
00294             }
00295             double phi1 = cp1.fi() + 2 * cp1.cu() * s1;
00296             double phi2 = cp2.fi() + 2 * cp2.cu() * s2;
00297             double f = (1 + 2 * cp1.cu() * cp1.da()) *
00298               (1 + 2 * cp2.cu() * cp2.da()) * cos(cp1.fi()-cp2.fi());
00299             f -= 2 * (lp1.gamma() * lp2.kappa() + lp2.gamma() * lp1.kappa());
00300             double cosphi12 = f;
00301           }
00302           return 2;
00303         }
00304       }
00305     }
00306   }
00307   return 0;
00308 }

Lpar::Cpar [friend]
 

Lpav [friend]
 

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

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

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

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

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

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

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

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

Member Data Documentation

const double Lpar::BELLE_ALPHA [static, private]
 

double Lpar::m_alpha [private]
 

double Lpar::m_beta [private]
 

double Lpar::m_gamma [private]
 

double Lpar::m_kappa [private]
 

IMagneticFieldSvc* Lpar::m_pmgnIMF [private]
 

IMagneticFieldSvc* Lpar::m_pmgnIMF [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:21:35 2011 for BOSS6.5.5 by  doxygen 1.3.9.1