Lpar Class Reference

#include <Lpar.h>

Inheritance diagram for Lpar:

Lpav Lpav List of all members.

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

Private Member Functions

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

Private Attributes

double m_alpha
double m_beta
double m_gamma
double m_kappa
IMagneticFieldSvc * m_pmgnIMF

Static Private Attributes

static const double BELLE_ALPHA

Friends

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

Classes

class  Cpar
class  Cpar

Detailed Description

Definition at line 42 of file Lpar.h.

Constructor & Destructor Documentation

Lpar::Lpar (  )  [inline]

Definition at line 156 of file Lpar.h.

References m_alpha, m_beta, m_gamma, and m_kappa.

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

Lpar::~Lpar (  )  [virtual]

Definition at line 52 of file Lpar.cxx.

00053 {
00054 }

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

Definition at line 163 of file Lpar.h.

References m_alpha, m_beta, m_gamma, and m_kappa.

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]

Member Function Documentation

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

Definition at line 127 of file Lpar.h.

References m_alpha.

00127 { return m_alpha; }

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

Definition at line 119 of file Lpar.h.

References m_alpha.

Referenced by intersect(), s(), and xhyh().

00119 { return m_alpha; }

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

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

Definition at line 228 of file Lpar.h.

References cross(), m_alpha, m_beta, m_kappa, M_PI, and xi2().

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]

Definition at line 128 of file Lpar.h.

References m_beta.

00128 { return m_beta; }

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

Definition at line 120 of file Lpar.h.

References m_beta.

Referenced by intersect(), s(), and xhyh().

00120 { return m_beta; }

HepVector Lpar::center (  )  const

HepVector Lpar::center (  )  const

Definition at line 228 of file Lpar.cxx.

Referenced by TCircleFitter::fit(), TCircle::fitForCurl(), TCurlFinder::fitWDD(), TBuilderCurl::fitWDD(), intersect(), FTTrack::r_phiFit(), FTWire::z(), and KalFitWire::z().

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]

Definition at line 193 of file Lpar.h.

References m_alpha, m_beta, m_gamma, and m_kappa.

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 
)

Definition at line 77 of file Lpar.cxx.

References m_alpha, m_beta, m_gamma, and m_kappa.

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]

Definition at line 208 of file Lpar.h.

References d0(), and m_kappa.

Referenced by FTFinder::CorrectEvtTiming(), Lpav::delta_chisq(), intersect(), operator+(), FTTrack::r_phi2Fit(), FTTrack::r_phi3Fit(), FTTrack::r_phi4Fit(), FTTrack::r_phiFit(), and FTTrack::r_phiReFit().

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]

Definition at line 204 of file Lpar.h.

References m_alpha, m_beta, m_gamma, and m_kappa.

Referenced by d(), Lpav::delta_chisq(), Hpar(), operator+(), s(), and sd().

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

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

Definition at line 142 of file Lpar.h.

References gamma(), and xi2().

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

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

Definition at line 134 of file Lpar.h.

References gamma(), and xi2().

Referenced by s().

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

HepMatrix Lpar::dldc (  )  const [private]

HepMatrix Lpar::dldc (  )  const [private]

Definition at line 132 of file Lpar.cxx.

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]

Definition at line 215 of file Lpar.h.

References m_kappa, xc(), and yc().

Referenced by xhyh().

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]

Definition at line 129 of file Lpar.h.

References m_gamma.

00129 { return m_gamma; }

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

Definition at line 121 of file Lpar.h.

References m_gamma.

Referenced by da(), and intersect().

00121 { return m_gamma; }

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

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

Definition at line 269 of file Lpar.h.

References BELLE_ALPHA, d0(), m_kappa, M_PI, xc(), and yc().

Referenced by FTTrack::r_phi2Fit(), FTTrack::r_phi3Fit(), FTTrack::r_phi4Fit(), FTTrack::r_phiFit(), FTTrack::r_phiReFit(), and FTTrack::s_zFit().

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]

Definition at line 73 of file Lpar.h.

References m_kappa.

00073 { return m_kappa; }

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

Definition at line 63 of file Lpar.h.

References m_kappa.

Referenced by TCircleFitter::fit(), TCircle::fitForCurl(), TCurlFinder::fitWDD(), TBuilderCurl::fitWDD(), intersect(), s(), and xhyh().

00063 { return m_kappa; }

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

Definition at line 133 of file Lpar.h.

References m_gamma, and m_kappa.

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

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

Definition at line 125 of file Lpar.h.

References m_gamma, and m_kappa.

Referenced by xy().

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]

Definition at line 187 of file Lpar.h.

References m_alpha, m_beta, m_gamma, and m_kappa.

Referenced by Lpav::calculate_lpar().

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]

Definition at line 197 of file Lpar.h.

References m_alpha, m_beta, m_gamma, and m_kappa.

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

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]

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

Reimplemented in Lpav, and Lpav.

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

Reimplemented in Lpav, and Lpav.

Definition at line 170 of file Lpar.h.

References m_alpha, m_beta, m_gamma, and m_kappa.

Referenced by Lpav::operator=().

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]

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

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

Definition at line 187 of file Lpar.cxx.

References M_PI, x(), xy(), and y().

Referenced by FTFinder::makeTds(), and sd().

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]

Definition at line 222 of file Lpar.h.

References m_gamma, and m_kappa.

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]

Definition at line 74 of file Lpar.h.

References m_kappa.

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

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

Definition at line 64 of file Lpar.h.

References m_kappa.

Referenced by TCircleFitter::fit(), TCircle::fitForCurl(), TCurlFinder::fitWDD(), TBuilderCurl::fitWDD(), FTWire::z(), and KalFitWire::z().

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]

Definition at line 180 of file Lpar.h.

References m_alpha, and m_beta.

Referenced by Lpav::calculate_lpar().

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

Definition at line 219 of file Lpar.cxx.

References d0(), da(), kappa(), and M_PI.

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

Definition at line 207 of file Lpar.cxx.

References alpha(), beta(), kappa(), M_PI, xhyh(), and xi2().

Referenced by intersect(), and FTTrack::s_zFit().

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]

Definition at line 122 of file Lpar.h.

References m_gamma, and m_kappa.

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

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

Definition at line 114 of file Lpar.h.

References m_gamma, and m_kappa.

Referenced by Lpav::calculate_lpar().

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]

Definition at line 249 of file Lpar.h.

References abs, d0(), m_alpha, m_beta, m_kappa, phi(), sin(), xc(), and yc().

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]

Definition at line 175 of file Lpar.cxx.

References xy().

Referenced by Lpav::extrapolate(), and phi().

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]

Definition at line 140 of file Lpar.h.

References m_alpha, and m_kappa.

00140 { return - m_alpha/2/m_kappa; }

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

Definition at line 132 of file Lpar.h.

References m_alpha, and m_kappa.

Referenced by dr(), Hpar(), and sd().

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]

Definition at line 195 of file Lpar.cxx.

References alpha(), beta(), dr(), and kappa().

Referenced by s().

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]

Definition at line 137 of file Lpar.h.

References m_gamma, and m_kappa.

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

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

Definition at line 129 of file Lpar.h.

References m_gamma, and m_kappa.

Referenced by arcfun(), da(), s(), and xy().

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]

Definition at line 159 of file Lpar.cxx.

References kr2g(), m_alpha, m_beta, and xi2().

Referenced by Lpav::extrapolate(), phi(), x(), and y().

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]

Definition at line 181 of file Lpar.cxx.

References xy().

Referenced by Lpav::extrapolate(), and phi().

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]

Definition at line 141 of file Lpar.h.

References m_beta, and m_kappa.

00141 { return - m_beta/2/m_kappa; }

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

Definition at line 133 of file Lpar.h.

References m_beta, and m_kappa.

Referenced by dr(), Hpar(), and sd().

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]

Definition at line 242 of file Lpar.cxx.

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]

Definition at line 242 of file Lpar.cxx.

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]

Definition at line 105 of file Lpar.h.

Lpav [friend]

Definition at line 78 of file Lpar.h.

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

Definition at line 318 of file Lpar.cxx.

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]

Definition at line 318 of file Lpar.cxx.

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]

Definition at line 144 of file Lpar.h.

Referenced by Hpar().

double Lpar::m_alpha [private]

Definition at line 138 of file Lpar.h.

Referenced by alpha(), arcfun(), Lpav::calculate_lpar(), Lpav::calculate_lpar3(), check(), circle(), d0(), Lpar(), move(), neg(), operator=(), rotate(), sd(), xc(), and xy().

double Lpar::m_beta [private]

Definition at line 139 of file Lpar.h.

Referenced by arcfun(), beta(), Lpav::calculate_lpar(), Lpav::calculate_lpar3(), check(), circle(), d0(), Lpar(), move(), neg(), operator=(), rotate(), sd(), xy(), and yc().

double Lpar::m_gamma [private]

Definition at line 140 of file Lpar.h.

Referenced by Lpav::calculate_lpar(), Lpav::calculate_lpar3(), check(), circle(), d0(), gamma(), kr2g(), Lpar(), move(), neg(), operator=(), r_max(), scale(), and xi2().

double Lpar::m_kappa [private]

Definition at line 141 of file Lpar.h.

Referenced by arcfun(), Lpav::calculate_lpar(), Lpav::calculate_lpar3(), check(), circle(), d(), d0(), dr(), Hpar(), kappa(), kr2g(), Lpar(), move(), neg(), operator=(), r_max(), radius(), scale(), sd(), xc(), xi2(), and yc().

IMagneticFieldSvc* Lpar::m_pmgnIMF [private]

Definition at line 61 of file Lpar.h.

Generated on Tue Nov 29 23:20:03 2016 for BOSS_7.0.2 by  doxygen 1.4.7