HelixTraj Class Reference

#include <HelixTraj.h>

Inheritance diagram for HelixTraj:

TrkSimpTraj TrkDifTraj TrkKalDeriv Trajectory List of all members.

Public Types

 d0Index = 0
 phi0Index
 omegaIndex
 z0Index
 tanDipIndex
 NHLXPRM = 5
enum  ParIndex {
  d0Index = 0, phi0Index, omegaIndex, z0Index,
  tanDipIndex
}
enum  { NHLXPRM = 5 }

Public Member Functions

 HelixTraj (const HepVector &, const HepSymMatrix &, double lowlim=-99999., double hilim=99999., const HepPoint3D &refpoint=_theOrigin)
 HelixTraj (const TrkExchangePar &, double lowlim=-99999., double hilim=99999., const HepPoint3D &refpoint=_theOrigin)
 HelixTraj (const TrkParams &, double lowlim=-99999., double hilim=99999., const HepPoint3D &refpoint=_theOrigin)
 HelixTraj (const HelixTraj &)
HelixTraj * clone () const
virtual ~HelixTraj ()
HelixTraj & operator= (const HelixTraj &)
virtual HepPoint3D position (double fltLen) const
virtual Hep3Vector direction (double fltLen) const
virtual Hep3Vector delDirect (double) const
virtual void getInfo (double fltLen, HepPoint3D &pos, Hep3Vector &dir) const
virtual void getInfo (double fltLen, HepPoint3D &, Hep3Vector &dir, Hep3Vector &delDir) const
virtual void getDFInfo (double fltLen, DifPoint &, DifVector &dir, DifVector &delDir) const
virtual void getDFInfo2 (double fltLen, DifPoint &pos, DifVector &dir) const
virtual double distTo1stError (double s, double tol, int pathDir) const
virtual double distTo2ndError (double s, double tol, int pathDir) const
double curvature (double fltLen) const
HepMatrix derivDeflect (double fltlen, deflectDirection) const
HepMatrix derivDisplace (double fltlen, deflectDirection idir) const
HepMatrix derivPFract (double fltlen) const
TranslateParams paramFunction () const
void invertParams (TrkParams *params, std::vector< bool > &flags) const
int nPar () const
double d0 () const
double phi0 () const
double omega () const
double z0 () const
double tanDip () const
virtual void visitAccept (TrkVisitor *vis) const
virtual void print (std::ostream &os) const
virtual void printAll (std::ostream &os) const
TrkParams * parameters ()
const TrkParams * parameters () const
virtual const TrkSimpTraj * localTrajectory (double fltLen, double &localFlt) const
const HepPoint3D & referencePoint () const
void changePoint (const HepPoint3D &newpoint, double &fltlen)
void setPoint (const HepPoint3D &newpoint)
TrkSimpTraj & invert ()
bool operator== (const TrkSimpTraj &) const
double distTo0thError (double s, double tol, int pathDir) const
bool validFlightDistance (double f, double tolerance=0.0) const
virtual void setFlightRange (double newrange[2])
double lowRange () const
double hiRange () const
double range () const

Static Public Attributes

static HepPoint3D _theOrigin

Protected Attributes

TrkParams _dtparams
HepPoint3D _refpoint
double flightrange [2]

Private Member Functions

double z (const double &) const
double dip () const
double cosDip () const
double sinDip () const
double translen (const double &f) const
double arc (const double &f) const
double angle (const double &f) const

Static Private Member Functions

static void paramFunc (const HepPoint3D &oldpoint, const HepPoint3D &newpoint, const HepVector &oldpar, const HepSymMatrix &oldcov, HepVector &newpar, HepSymMatrix &newcov, double fltlen)

Detailed Description

Definition at line 27 of file HelixTraj.h.

Member Enumeration Documentation

anonymous enum

Enumerator:
NHLXPRM 

Definition at line 31 of file HelixTraj.h.

00031 {NHLXPRM = 5};

enum HelixTraj::ParIndex

Enumerator:
d0Index 
phi0Index 
omegaIndex 
z0Index 
tanDipIndex 

Definition at line 30 of file HelixTraj.h.

00030 {d0Index=0, phi0Index, omegaIndex, z0Index, tanDipIndex};

Constructor & Destructor Documentation

HelixTraj::HelixTraj ( const HepVector &  ,
const HepSymMatrix &  ,
double  lowlim = -99999.,
double  hilim = 99999.,
const HepPoint3D &  refpoint = _theOrigin 
)

Definition at line 28 of file HelixTraj.cxx.

References NHLXPRM, omega(), omegaIndex, DifIndepPar::parameter(), and TrkSimpTraj::parameters().

Referenced by clone().

00029                                                                               :
00030   TrkSimpTraj(pvec, pcov, lowlim,hilim,refpoint)
00031 {
00032   //  Make sure the dimensions of the input matrix and vector are correct
00033 
00034   if( pvec.num_row() != NHLXPRM || pcov.num_row() != NHLXPRM ){
00035     std::cout<<"ErrMsg(fatal) " 
00036       << "HelixTraj: incorrect constructor vector/matrix dimension" << std::endl;
00037       ::abort();
00038   }
00039 
00040   if (omega() == 0.0) parameters()->parameter()[omegaIndex] = 1.e-9;
00041 }

HelixTraj::HelixTraj ( const TrkExchangePar &  ,
double  lowlim = -99999.,
double  hilim = 99999.,
const HepPoint3D &  refpoint = _theOrigin 
)

Definition at line 44 of file HelixTraj.cxx.

References omega(), omegaIndex, DifIndepPar::parameter(), and TrkSimpTraj::parameters().

00045                                                                               :
00046   TrkSimpTraj(inpar.params(), inpar.covariance(), lowlim,hilim,refpoint)
00047 {
00048   if (omega() == 0.0) parameters()->parameter()[omegaIndex] = 1.e-9;
00049 }

HelixTraj::HelixTraj ( const TrkParams &  ,
double  lowlim = -99999.,
double  hilim = 99999.,
const HepPoint3D &  refpoint = _theOrigin 
)

Definition at line 51 of file HelixTraj.cxx.

References NHLXPRM, omega(), omegaIndex, DifIndepPar::parameter(), and TrkSimpTraj::parameters().

00052                                                                               :
00053   TrkSimpTraj(inpar, lowlim,hilim,refpoint)
00054 {
00055   assert(inpar.parameter().num_row()==NHLXPRM);
00056   if (omega() == 0.0) parameters()->parameter()[omegaIndex] = 1.e-9;
00057 }

HelixTraj::HelixTraj ( const HelixTraj &   ) 

Definition at line 59 of file HelixTraj.cxx.

00060   : TrkSimpTraj(h.parameters()->parameter(), h.parameters()->covariance(), 
00061                 h.lowRange(),h.hiRange(),h.referencePoint())
00062 {
00063 }

HelixTraj::~HelixTraj (  )  [virtual]

Definition at line 82 of file HelixTraj.cxx.

00083 {
00084 }

Member Function Documentation

double HelixTraj::angle ( const double &  f  )  const [private]

Definition at line 631 of file HelixTraj.cxx.

References arc(), and phi0().

Referenced by delDirect(), and direction().

00632 {
00633   return BesAngle(phi0() + arc(f));
00634 }

double HelixTraj::arc ( const double &  f  )  const [inline, private]

Definition at line 108 of file HelixTraj.h.

References omega(), and translen().

Referenced by angle(), derivDeflect(), and derivDisplace().

00108 {return translen(f)*omega();}

void TrkSimpTraj::changePoint ( const HepPoint3D &  newpoint,
double &  fltlen 
) [inherited]

Definition at line 70 of file TrkSimpTraj.cxx.

References TrkSimpTraj::_dtparams, TrkSimpTraj::_refpoint, TrkParams::covariance(), TrkErrCode::failure(), TrkPocaBase::flt1(), Trajectory::hiRange(), icol, Trajectory::lowRange(), DifIndepPar::parameter(), TrkSimpTraj::parameters(), TrkSimpTraj::paramFunction(), Trajectory::setFlightRange(), and TrkPocaBase::status().

00070                                                                   {
00071 //----------------------------------------------------------------------------
00072   if(newpoint != _refpoint){
00073 //  find POCA to the new point
00074     TrkPocaXY endpoca(*this,fltlen,newpoint);
00075     if(endpoca.status().failure()){
00076       std::cout<<"ErrMsg(error)" << "poca failure changing reference point" << std::endl;
00077       return;
00078     } else {
00079 // update flight length
00080       fltlen = endpoca.flt1();
00081 // make a symmatrix from the covariance: temporary kludge
00082       int nrow = parameters()->covariance().num_row();
00083       HepSymMatrix cov(nrow);
00084       for(int irow=0;irow<nrow;irow++)
00085         for(int icol=0;icol<=irow;icol++)
00086           cov.fast(irow+1,icol+1) = parameters()->covariance().fast(irow+1,icol+1);
00087 //  Get the translation function
00088       TranslateParams pfunc = paramFunction();
00089 //  Use it on the SimpTraj parameters
00090       pfunc(_refpoint,newpoint,
00091             parameters()->parameter(),cov,
00092             _dtparams.parameter(),cov,
00093             fltlen);
00094 // put back the covariance
00095       _dtparams.covariance() = cov;
00096       _refpoint = newpoint;
00097 // update the flight range to correspond to the same range in space as before
00098       double newrange[2];
00099       newrange[0] = lowRange() - fltlen;
00100       newrange[1] = hiRange() - fltlen;
00101       setFlightRange(newrange);
00102     }
00103   }
00104   return;
00105 }

HelixTraj * HelixTraj::clone (  )  const [virtual]

Implements TrkSimpTraj.

Definition at line 66 of file HelixTraj.cxx.

References HelixTraj().

00067 {
00068   return new HelixTraj(*this);
00069 }

double HelixTraj::cosDip (  )  const [inline, private]

Definition at line 105 of file HelixTraj.h.

References tanDip().

Referenced by curvature(), delDirect(), derivDeflect(), derivDisplace(), direction(), getInfo(), position(), sinDip(), and translen().

00105 {return 1./sqrt(1.+tanDip()*tanDip()); }

double HelixTraj::curvature ( double  fltLen  )  const [virtual]

Implements Trajectory.

Definition at line 499 of file HelixTraj.cxx.

References cosDip(), and omega().

00500 {
00501 //  Compute the curvature as the magnitude of the 2nd derivative
00502 //  of the position function with respect to the 3-d flight distance
00503 //
00504   double cosd = cosDip();
00505 //  return sqr(cosd)*fabs(omega());
00506   return (cosd*cosd)*fabs(omega());
00507 }

double HelixTraj::d0 (  )  const [inline]

Definition at line 79 of file HelixTraj.h.

References d0Index, DifIndepPar::parameter(), and TrkSimpTraj::parameters().

Referenced by derivDeflect(), derivDisplace(), derivPFract(), getDFInfo(), getDFInfo2(), getInfo(), and position().

00079 {return parameters()->parameter()[d0Index];}

Hep3Vector HelixTraj::delDirect ( double   )  const [virtual]

Implements Trajectory.

Definition at line 123 of file HelixTraj.cxx.

References angle(), cos(), cosDip(), omega(), and sin().

00124 {
00125   double ang = angle(fltLen);
00126   double cDip = cosDip();
00127   double delX = -omega() * cDip * cDip * sin(ang);
00128   double delY =  omega() * cDip * cDip * cos(ang);
00129   return Hep3Vector(delX, delY, 0.0);
00130 }

HepMatrix HelixTraj::derivDeflect ( double  fltlen,
deflectDirection   
) const [virtual]

Implements TrkKalDeriv.

Definition at line 365 of file HelixTraj.cxx.

References arc(), cos(), cosDip(), d0(), d0Index, NHLXPRM, omega(), omegaIndex, phi0Index, sin(), tanDip(), tanDipIndex, theta1, theta2, translen(), and z0Index.

00366 {
00367 //
00368 //  This function computes the column matrix of derrivatives for the change
00369 //  in parameters for a change in the direction of a track at a point along
00370 //  its flight, holding the momentum and position constant.  The effects for
00371 //  changes in 2 perpendicular directions (theta1 = dip and
00372 //  theta2 = phi*cos(dip)) can sometimes be added, as scattering in these
00373 //  are uncorrelated.
00374 //
00375   HepMatrix ddflct(NHLXPRM,1);
00376 //
00377 //  Compute some common things
00378 //
00379   double omeg = omega();
00380   double tand = tanDip();
00381   double arcl = arc(fltlen);
00382   double dx = cos(arcl);
00383   double dy = sin(arcl);
00384   double cosd = cosDip();
00385   double darc = omeg*d0();
00386 //
00387 //  Go through the parameters
00388 //
00389   switch (idirect) {
00390   case theta1:
00391     ddflct(omegaIndex+1,1) = omeg*tand;
00392 //    ddflct(tanDipIndex+1,1) = 1.0/sqr(cosd);
00393     ddflct(tanDipIndex+1,1) = 1.0/(cosd*cosd);
00394     ddflct(d0Index+1,1) = (1-dx)*tand/omeg;
00395     ddflct(phi0Index+1,1) =  -dy*tand/(1+darc);
00396 //    ddflct(z0Index+1,1) = - translen(fltlen) - sqr(tand)*dy/(omeg*(1+darc));
00397     ddflct(z0Index+1,1) = - translen(fltlen) - (tand*tand)*dy/(omeg*(1+darc));
00398     break;
00399   case theta2:
00400     ddflct(omegaIndex+1,1) = 0;
00401     ddflct(tanDipIndex+1,1) = 0;
00402     ddflct(d0Index+1,1) = -dy/(cosd*omeg);
00403     ddflct(phi0Index+1,1) = dx/(cosd*(1+darc));
00404     ddflct(z0Index+1,1) = -tand*(1- dx/(1+darc))/(cosd*omeg);
00405     break;
00406   }
00407 
00408   return ddflct;
00409 }

HepMatrix HelixTraj::derivDisplace ( double  fltlen,
deflectDirection  idir 
) const [virtual]

Implements TrkKalDeriv.

Definition at line 413 of file HelixTraj.cxx.

References arc(), cos(), cosDip(), d0(), d0Index, NHLXPRM, omega(), omegaIndex, phi0Index, sin(), sinDip(), tanDip(), tanDipIndex, theta1, theta2, and z0Index.

00414 {
00415 //
00416 //  This function computes the column matrix of derrivatives for the change
00417 //  in parameters for a change in the position of a track at a point along
00418 //  its flight, holding the momentum and direction constant.  The effects for
00419 //  changes in 2 perpendicular directions 'theta1' = (-sin(l)cos(p),-sin(l)sin(p),cos(l)) and
00420 //  'theta2' = (-sin(p),cos(p),0).  These are by definition orthogonal and uncorrelated.
00421 //  these displacements are correlated with the angular change above
00422 //
00423   HepMatrix ddflct(NHLXPRM,1);
00424 //
00425 //  Compute some common things
00426 //
00427   double omeg = omega();
00428   double tand = tanDip();
00429   double arcl = arc(fltlen);
00430   double dx = cos(arcl);
00431   double dy = sin(arcl);
00432   double cosd = cosDip();
00433   double sind = sinDip();
00434   double darc_1 = 1.0+omeg*d0();
00435 //
00436 //  Go through the parameters
00437 //
00438   switch (idirect) {
00439   case theta1:
00440     ddflct(omegaIndex+1,1) = 0.0;
00441     ddflct(tanDipIndex+1,1) = 0.0;
00442     ddflct(d0Index+1,1) = -sind*dy;
00443     ddflct(phi0Index+1,1) = sind*dx*omeg/darc_1;
00444     ddflct(z0Index+1,1) = sind*tand*dx/darc_1 + cosd;
00445     break;
00446   case theta2:
00447     ddflct(omegaIndex+1,1) = 0;
00448     ddflct(tanDipIndex+1,1) = 0;
00449     ddflct(d0Index+1,1) = dx;
00450     ddflct(phi0Index+1,1) = dy*omeg/darc_1;
00451     ddflct(z0Index+1,1) = tand*dy/darc_1;
00452     break;
00453   }
00454 
00455   return ddflct;
00456 }

HepMatrix HelixTraj::derivPFract ( double  fltlen  )  const [virtual]

Implements TrkKalDeriv.

Definition at line 460 of file HelixTraj.cxx.

References cos(), d0(), d0Index, NHLXPRM, omega(), omegaIndex, phi0Index, sin(), tanDip(), tanDipIndex, translen(), and z0Index.

00461 {
00462 //
00463 //  This function computes the column matrix of derrivatives for the change
00464 //  in parameters from a (fractional) change in the track momentum,
00465 //  holding the direction and position constant.  The momentum change can
00466 //  come from energy loss or bfield inhomogeneities.
00467 //
00468 //  For a helix, dp/P = -domega/omega,
00469 //  dParam/d(domega/omega) = -omega*dParam/ddomega
00470 //
00471   HepMatrix dmomfrac(NHLXPRM,1);
00472 //
00473 //  Compute some common things
00474 
00475   double omeg = omega();
00476   double tand = tanDip();
00477   double tranl = translen(fltlen);
00478   double arcl = tranl*omeg;
00479   double dx = cos(arcl);
00480   double dy = sin(arcl);
00481   double darc = omeg*d0();
00482 
00483 //  Go through the parameters
00484 // omega
00485   dmomfrac(omegaIndex+1,1) = -omeg;
00486 // tanDip
00487   dmomfrac(tanDipIndex+1,1) = 0.0;
00488 // d0
00489   dmomfrac(d0Index+1,1) = -(1-dx)/omeg;
00490 // phi0
00491   dmomfrac(phi0Index+1,1) = dy/(1+darc);
00492 // z0
00493   dmomfrac(z0Index+1,1) = -tand*(tranl-dy/((1+darc)*omeg));
00494 //
00495   return dmomfrac;
00496 }

double HelixTraj::dip (  )  const [inline, private]

Definition at line 103 of file HelixTraj.h.

References tanDip().

00103 {return atan(tanDip());}

Hep3Vector HelixTraj::direction ( double  fltLen  )  const [virtual]

Implements Trajectory.

Definition at line 110 of file HelixTraj.cxx.

References alpha, angle(), cos(), cosDip(), sin(), and tanDip().

00111 {
00112   // Angle formed by tangent vector after
00113   // being rotated 'arclength' around orbit.
00114   double alpha = angle( f );
00115   // Construct 3-D tangent vector of unit magnitude.
00116   double cDip = cosDip();
00117   return Hep3Vector ( cos(alpha)*cDip,
00118                       sin(alpha)*cDip,
00119                       cDip*tanDip() );
00120 }

double Trajectory::distTo0thError ( double  s,
double  tol,
int  pathDir 
) const [inherited]

Definition at line 51 of file Trajectory.cxx.

00052 {
00053   return fabs(tolerance);
00054 }

double HelixTraj::distTo1stError ( double  s,
double  tol,
int  pathDir 
) const [virtual]

Implements Trajectory.

Definition at line 133 of file HelixTraj.cxx.

References omega(), and tanDip().

00134 {
00135 //  return sqrt(2.*tol/fabs(omega())*(1.+sqr(tanDip())));
00136   return sqrt(2.*tol/fabs(omega())*(1.+tanDip()*tanDip()));
00137 }

double HelixTraj::distTo2ndError ( double  s,
double  tol,
int  pathDir 
) const [virtual]

Implements Trajectory.

Definition at line 140 of file HelixTraj.cxx.

References omega(), and tanDip().

00141 {
00142 //  return sqrt(1.+sqr(tanDip()))*cbrt(6.*tol/sqr(omega()));
00143   return sqrt(1.+tanDip()*tanDip())*cbrt(6.*tol/omega()*omega());
00144 }

void HelixTraj::getDFInfo ( double  fltLen,
DifPoint &  ,
DifVector &  dir,
DifVector &  delDir 
) const [virtual]

Implements TrkDifTraj.

Definition at line 280 of file HelixTraj.cxx.

References DifNumber::cosAndSin(), d0(), d0Index, DifNumber::mod(), NHLXPRM, omega(), omegaIndex, TrkSimpTraj::parameters(), phi0(), phi0Index, Constants::pi, boss::pos, TrkSimpTraj::referencePoint(), DifNumber::setIndepPar(), tanDip(), tanDipIndex, subSeperate::temp, x, DifVector::x, DifVector::y, z(), DifVector::z, z0(), and z0Index.

00282 {
00283   //Provides difNum version of information for calculation of derivatives.
00284   //  All arithmetic operations have been replaced by +=, etc. versions 
00285   //  for speed.
00286 
00287   // Create difNumber versions of parameters
00288   DifNumber phi0Df(phi0(), phi0Index+1, NHLXPRM);
00289   DifNumber d0Df(d0(), d0Index+1, NHLXPRM);
00290   DifNumber z0Df(z0(), z0Index+1, NHLXPRM);
00291   DifNumber tanDipDf(tanDip(), tanDipIndex+1, NHLXPRM);
00292   DifNumber omegaDf(omega(), omegaIndex+1, NHLXPRM);
00293   phi0Df.setIndepPar( parameters() );
00294   d0Df.setIndepPar( parameters() );
00295   z0Df.setIndepPar( parameters() );
00296   tanDipDf.setIndepPar( parameters() );
00297   omegaDf.setIndepPar( parameters() );
00298   DifNumber dipDf = atan(tanDipDf);
00299 
00300   static DifNumber cDip;
00301   dipDf.cosAndSin(cDip, dir.z);
00302   static DifNumber sinPhi0, cosPhi0;
00303   phi0Df.cosAndSin(cosPhi0, sinPhi0);
00304 
00305   bool lref = (referencePoint().x() != 0. || referencePoint().y() != 0. ||
00306                referencePoint().z() != 0.);
00307 
00308   DifNumber alphaDf = cDip;
00309   alphaDf *= omegaDf;
00310   alphaDf *= flt;
00311   alphaDf += phi0Df;
00312 
00313   // This is not the prettiest line imaginable for this operation:
00314   alphaDf.mod(-Constants::pi, Constants::pi);
00315   //  DifNumber sinAlpha, cosAlpha;
00316   alphaDf.cosAndSin(dir.x, dir.y);
00317 
00318   //  DifNumber x =   (sinAlpha - sinPhi0) / omegaDf - d0Df * sinPhi0 + px;
00319   //  DifNumber y =  -(cosAlpha - cosPhi0) / omegaDf + d0Df * cosPhi0 + py;
00320 
00321   pos.x = dir.y;
00322   pos.x -= sinPhi0;
00323   pos.x /= omegaDf;
00324   DifNumber temp = d0Df;
00325   temp *= sinPhi0;
00326   pos.x -= temp;
00327 
00328   pos.y = cosPhi0;
00329   pos.y -= dir.x;
00330   pos.y /= omegaDf;
00331   temp = d0Df;
00332   temp *= cosPhi0;
00333   pos.y += temp;
00334 
00335   pos.z = flt;
00336   pos.z *= dir.z;
00337   pos.z += z0Df;
00338 
00339   if (lref) {
00340     DifNumber px(referencePoint().x());
00341     DifNumber py(referencePoint().y());
00342     DifNumber pz(referencePoint().z());
00343     pos.x += px;
00344     pos.y += py;
00345     pos.z += pz;
00346   }
00347 
00348   delDir.x = -omegaDf;
00349   delDir.x *= cDip;
00350   delDir.x *= cDip;
00351   delDir.x *= dir.y;
00352 
00353   delDir.y =  omegaDf;
00354   delDir.y *= cDip;
00355   delDir.y *= cDip;
00356   delDir.y *= dir.x;
00357 
00358   delDir.z = 0.;
00359 
00360   dir.x *= cDip;
00361   dir.y *= cDip;
00362 }

void HelixTraj::getDFInfo2 ( double  fltLen,
DifPoint &  pos,
DifVector &  dir 
) const [virtual]

Reimplemented from TrkDifTraj.

Definition at line 207 of file HelixTraj.cxx.

References DifNumber::cosAndSin(), d0(), d0Index, DifNumber::mod(), NHLXPRM, omega(), omegaIndex, TrkSimpTraj::parameters(), phi0(), phi0Index, Constants::pi, boss::pos, TrkSimpTraj::referencePoint(), DifNumber::setIndepPar(), tanDip(), tanDipIndex, subSeperate::temp, x, DifVector::x, DifVector::y, z(), DifVector::z, z0(), and z0Index.

00208 {
00209   //Provides difNum version of information for calculation of derivatives.
00210   //  All arithmetic operations have been replaced by +=, etc. versions 
00211   //  for speed.
00212 
00213   // Create difNumber versions of parameters
00214   DifNumber phi0Df(phi0(), phi0Index+1, NHLXPRM);
00215   phi0Df.setIndepPar( parameters() );
00216   DifNumber d0Df(d0(), d0Index+1, NHLXPRM);
00217   d0Df.setIndepPar( parameters() );
00218   DifNumber z0Df(z0(), z0Index+1, NHLXPRM);
00219   z0Df.setIndepPar( parameters() );
00220   DifNumber tanDipDf(tanDip(), tanDipIndex+1, NHLXPRM);
00221   tanDipDf.setIndepPar( parameters() );
00222   DifNumber omegaDf(omega(), omegaIndex+1, NHLXPRM);
00223   omegaDf.setIndepPar( parameters() );
00224 
00225   DifNumber dipDf = atan(tanDipDf);
00226 
00227   static DifNumber cDip;
00228   dipDf.cosAndSin(cDip, dir.z);
00229   static DifNumber sinPhi0, cosPhi0;
00230   phi0Df.cosAndSin(cosPhi0, sinPhi0);
00231 
00232   bool lref = (referencePoint().x() != 0. || referencePoint().y() != 0. ||
00233                referencePoint().z() != 0.);
00234 
00235   DifNumber alphaDf = cDip;
00236   alphaDf *= omegaDf;
00237   alphaDf *= flt;
00238   alphaDf += phi0Df;
00239 
00240   // This is not the prettiest line imaginable for this operation:
00241   alphaDf.mod(-Constants::pi, Constants::pi);
00242   //  DifNumber sinAlpha, cosAlpha;
00243   alphaDf.cosAndSin(dir.x, dir.y);
00244 
00245   //  DifNumber x =   (sinAlpha - sinPhi0) / omegaDf - d0Df * sinPhi0 + px;
00246   //  DifNumber y =  -(cosAlpha - cosPhi0) / omegaDf + d0Df * cosPhi0 + py;
00247 
00248   pos.x = dir.y;
00249   pos.x -= sinPhi0;
00250   pos.x /= omegaDf;
00251   DifNumber temp = d0Df;
00252   temp *= sinPhi0;
00253   pos.x -= temp;
00254 
00255   pos.y = cosPhi0;
00256   pos.y -= dir.x;
00257   pos.y /= omegaDf;
00258   temp = d0Df;
00259   temp *= cosPhi0;
00260   pos.y += temp;
00261 
00262   pos.z = flt;
00263   pos.z *= dir.z;
00264   pos.z += z0Df;
00265 
00266   if (lref) {
00267     DifNumber px(referencePoint().x());
00268     DifNumber py(referencePoint().y());
00269     DifNumber pz(referencePoint().z());
00270     pos.x += px;
00271     pos.y += py;
00272     pos.z += pz;
00273   }
00274 
00275   dir.x *= cDip;
00276   dir.y *= cDip;
00277 }

void HelixTraj::getInfo ( double  fltLen,
HepPoint3D &  ,
Hep3Vector &  dir,
Hep3Vector &  delDir 
) const [virtual]

Implements Trajectory.

Definition at line 147 of file HelixTraj.cxx.

References cos(), cosDip(), d0(), omega(), DifIndepPar::parameter(), TrkSimpTraj::parameters(), phi0Index, TrkSimpTraj::referencePoint(), sin(), tanDip(), and z0().

00149 {
00150   //  double ang = angle(fltLen);
00151   double cDip = cosDip();
00152   double sDip = tanDip() * cDip;
00153   double phi00 = parameters()->parameter()[phi0Index];  // Don't normalize
00154   double ang = phi00 + cDip*fltLen*omega(); 
00155   double cang = cos(ang);
00156   double sang = sin(ang);
00157   double sphi0 = sin(phi00);
00158   double cphi0 = cos(phi00);
00159 
00160   double xt = (sang - sphi0)/omega() - d0()*sphi0 +
00161     referencePoint().x();
00162   double yt = -(cang - cphi0)/omega() + d0()*cphi0 +
00163     referencePoint().y();
00164   double zt = z0() + fltLen*sDip + referencePoint().z();
00165   pos.setX(xt);
00166   pos.setY(yt);
00167   pos.setZ(zt);
00168 
00169   dir.setX(cang * cDip);
00170   dir.setY(sang * cDip);
00171   dir.setZ(sDip);
00172 
00173   double delX = -omega() * cDip * cDip * sang;
00174   double delY =  omega() * cDip * cDip * cang;
00175   delDir.setX(delX);
00176   delDir.setY(delY);
00177   delDir.setZ(0.0);
00178 }

void HelixTraj::getInfo ( double  fltLen,
HepPoint3D &  pos,
Hep3Vector &  dir 
) const [virtual]

Implements Trajectory.

Definition at line 181 of file HelixTraj.cxx.

References cos(), cosDip(), d0(), omega(), DifIndepPar::parameter(), TrkSimpTraj::parameters(), phi0Index, TrkSimpTraj::referencePoint(), sin(), tanDip(), and z0().

00182 {
00183   //  double ang = angle(fltLen);
00184   double cDip = cosDip();
00185   double sDip = tanDip() * cDip;
00186   double phi00 = parameters()->parameter()[phi0Index];  // Don't normalize
00187   double ang = phi00 + cDip*fltLen*omega(); 
00188   double cang = cos(ang);
00189   double sang = sin(ang);
00190   double sphi0 = sin(phi00);
00191   double cphi0 = cos(phi00);
00192 
00193   double xt = (sang - sphi0)/omega() - d0()*sphi0 +
00194     referencePoint().x();
00195   double yt = -(cang - cphi0)/omega() + d0()*cphi0 +
00196     referencePoint().y();
00197   double zt = z0() + fltLen*sDip + referencePoint().z();
00198   pos.setX(xt);
00199   pos.setY(yt);
00200   pos.setZ(zt);
00201 
00202   dir.setX(cang * cDip);
00203   dir.setY(sang * cDip);
00204   dir.setZ(sDip);
00205 }

double Trajectory::hiRange (  )  const [inline, inherited]

Definition at line 92 of file Trajectory.h.

References Trajectory::flightrange.

Referenced by TrkDifPieceTraj::append(), TrkSimpTraj::changePoint(), MdcUtilitySvc::docaPatPar(), TrkRep::endValidRange(), TrkCompTrk::endValidRange(), TrkSimpTraj::invert(), TrkDifPieceTraj::invert(), TrkDifPieceTraj::locallyValid(), MdcHitOnTrack::MdcHitOnTrack(), TrkSimpTraj::operator==(), TrkDifPieceTraj::prepend(), and Trajectory::range().

00092 {return flightrange[1];}

TrkSimpTraj & TrkSimpTraj::invert (  )  [inherited]

Reimplemented in NeutTraj.

Definition at line 128 of file TrkSimpTraj.cxx.

References TrkParams::covariance(), Trajectory::hiRange(), TrkSimpTraj::invertParams(), Trajectory::lowRange(), DifIndepPar::nPar(), TrkSimpTraj::nPar(), TrkSimpTraj::parameters(), Trajectory::range(), and Trajectory::setFlightRange().

00129 {
00130   // Invert parameters
00131   std::vector<bool> flags(parameters()->nPar(),false);
00132   invertParams(parameters(), flags);
00133   // loop over parameters and invert covariance matrix
00134   for(int iparam=0;iparam<parameters()->nPar();iparam++){
00135     bool iinvert = flags[iparam];
00136 // do covariance cross-terms too
00137     for(int jparam=iparam+1;jparam<parameters()->nPar();jparam++){
00138       bool jinvert = flags[jparam];
00139       if( (iinvert && !jinvert) || (!iinvert && jinvert) ) {
00140 // cross-terms change sign
00141         parameters()->covariance()[iparam][jparam] *= -1.0;
00142       }
00143     }
00144   }
00145 // invert the flightlength
00146   double range[2];
00147   range[0] = -hiRange();
00148   range[1] = -lowRange();
00149   setFlightRange(range);
00150 // done
00151   return *this;
00152 }

void HelixTraj::invertParams ( TrkParams *  params,
std::vector< bool > &  flags 
) const [virtual]

Implements TrkSimpTraj.

Definition at line 598 of file HelixTraj.cxx.

References d0Index, NHLXPRM, omegaIndex, DifIndepPar::parameter(), phi0Index, Constants::pi, tanDipIndex, and z0Index.

00599 {
00600   // Inverts parameters and returns true if the parameter inversion
00601   // requires a change in sign of elements in the covariance matrix
00602 
00603   for (unsigned iparam = 0; iparam < NHLXPRM; iparam++) {
00604     switch ( iparam ) {
00605     case d0Index:  // changes sign
00606     case omegaIndex:  // changes sign
00607     case tanDipIndex:  // changes sign
00608       params->parameter()[iparam] *= -1.0;
00609       flags[iparam] = true;
00610       break;
00611     case phi0Index:  // changes by pi, but covariance matrix shouldn't change
00612       params->parameter()[iparam] =
00613         BesAngle(params->parameter()[iparam] + Constants::pi);
00614       flags[iparam] = false;
00615       break;
00616     case z0Index:  // nochange
00617       flags[iparam] = false;
00618     }
00619   }
00620   return;
00621 }

const TrkSimpTraj * TrkSimpTraj::localTrajectory ( double  fltLen,
double &  localFlt 
) const [virtual, inherited]

Implements TrkDifTraj.

Definition at line 59 of file TrkSimpTraj.cxx.

00059                                                                   {
00060 //----------------------------------------------------------------------------
00061   localFlt = fltLen;
00062   return this;
00063 }

double Trajectory::lowRange (  )  const [inline, inherited]

Definition at line 91 of file Trajectory.h.

References Trajectory::flightrange.

Referenced by TrkDifPieceTraj::append(), TrkSimpTraj::changePoint(), MdcUtilitySvc::docaPatPar(), TrkSimpTraj::invert(), TrkDifPieceTraj::invert(), TrkDifPieceTraj::locallyValid(), MdcHitOnTrack::MdcHitOnTrack(), TrkSimpTraj::operator==(), TrkDifPieceTraj::prepend(), Trajectory::range(), TrkRep::startValidRange(), TrkCompTrk::startValidRange(), TrkDifPieceTraj::trajIndex(), and TrkDifPieceTraj::TrkDifPieceTraj().

00091 {return flightrange[0];}

int HelixTraj::nPar (  )  const [inline, virtual]

Reimplemented from TrkSimpTraj.

Definition at line 75 of file HelixTraj.h.

References NHLXPRM.

00075 { return NHLXPRM;}

double HelixTraj::omega (  )  const [inline]

Definition at line 81 of file HelixTraj.h.

References omegaIndex, DifIndepPar::parameter(), and TrkSimpTraj::parameters().

Referenced by arc(), curvature(), delDirect(), derivDeflect(), derivDisplace(), derivPFract(), distTo1stError(), distTo2ndError(), getDFInfo(), getDFInfo2(), getInfo(), HelixTraj(), and position().

00081 {return parameters()->parameter()[omegaIndex]; }

HelixTraj & HelixTraj::operator= ( const HelixTraj &   ) 

Definition at line 72 of file HelixTraj.cxx.

References TrkSimpTraj::_dtparams, TrkSimpTraj::_refpoint, and Trajectory::operator=().

00073 {
00074   if( &h != this ){
00075     Trajectory::operator=(h);
00076     _dtparams = *(h.parameters());
00077     _refpoint = h._refpoint;
00078   }
00079   return *this;
00080 }

bool TrkSimpTraj::operator== ( const TrkSimpTraj &   )  const [inherited]

Definition at line 156 of file TrkSimpTraj.cxx.

References TrkSimpTraj::_dtparams, TrkSimpTraj::_refpoint, Trajectory::hiRange(), genRecEmupikp::i, Trajectory::lowRange(), mp, DifIndepPar::parameter(), and x.

00157 {
00158      if (lowRange()!=x.lowRange() || hiRange()!=x.hiRange()) return false;
00159      const HepVector &m=_dtparams.parameter(); 
00160      unsigned int mp=m.num_row();
00161      const HepVector &n=x._dtparams.parameter(); 
00162      unsigned int np=n.num_row();
00163      if (np!=mp) return false;
00164      for(unsigned i=0;i<np;++i){
00165         if(m[i] != n[i]) return false;
00166      }
00167      return _refpoint==x._refpoint;
00168 }

const TrkParams* TrkSimpTraj::parameters (  )  const [inline, inherited]

Definition at line 81 of file TrkSimpTraj.h.

References TrkSimpTraj::_dtparams.

00081 {return &_dtparams;}

TrkParams* TrkSimpTraj::parameters (  )  [inline, inherited]

Definition at line 80 of file TrkSimpTraj.h.

References TrkSimpTraj::_dtparams.

Referenced by TrkMomCalculator::calcCurvAllCovs(), TrkMomCalculator::calcCurvAllWeights(), TrkMomCalculator::calcNeutAllCovs(), TrkMomCalculator::calcNeutAllWeights(), TrkMomCalculator::calcNeutErrMom(), TrkMomCalculator::calcNeutPosmomCov(), TrkSimpTraj::changePoint(), TrkMomCalculator::charge(), TrkDifLineTraj::d0(), TrkCircleTraj::d0(), d0(), TrkHelixFitter::fit(), TrkDifLineTraj::getDFInfo(), TrkCircleTraj::getDFInfo(), NeutTraj::getDFInfo(), getDFInfo(), TrkCircleTraj::getDFInfo2(), getDFInfo2(), getInfo(), TrkLineRep::helix(), TrkHelixRep::helix(), TrkCircleRep::helix(), HelixTraj(), TrkSimpTraj::invert(), TrkSimpleRep::nDof(), TrkSimpTraj::nPar(), TrkCircleTraj::omega(), omega(), TrkDifLineTraj::phi0(), TrkCircleTraj::phi0(), phi0(), position(), TrkMomCalculator::ptMom(), TrkHelixRep::resid(), TrkDifLineTraj::tanDip(), tanDip(), TrkCircleTraj::TrkCircleTraj(), TrkDifLineTraj::TrkDifLineTraj(), TrkHitOnTrk::TrkHitOnTrk(), TrkMomCalculator::vecMom(), TrkDifLineTraj::z0(), and z0().

00080 {return &_dtparams;}

void HelixTraj::paramFunc ( const HepPoint3D &  oldpoint,
const HepPoint3D &  newpoint,
const HepVector &  oldpar,
const HepSymMatrix &  oldcov,
HepVector &  newpar,
HepSymMatrix &  newcov,
double  fltlen 
) [static, private]

Definition at line 516 of file HelixTraj.cxx.

References cos(), d0Index, M_2PI, M_PI, NHLXPRM, omegaIndex, phi0Index, rad, sin(), tanDipIndex, and z0Index.

Referenced by paramFunction().

00520 {
00521 // copy the input parameter vector, in case the input and output are the same
00522   HepVector parvec(oldvec);
00523 // start with the input: omega and tandip don't change
00524   newvec = parvec;
00525 //
00526   double delx = newpoint.x()-oldpoint.x();
00527   double dely = newpoint.y()-oldpoint.y();
00528   double delz = newpoint.z()-oldpoint.z();
00529 //
00530   double rad = 1./parvec[omegaIndex];
00531   double rad2 = rad*rad;
00532   double delta = rad + parvec[d0Index];
00533   double cos0 = cos(parvec[phi0Index]);
00534   double sin0 = sin(parvec[phi0Index]);
00535   double perp = delx*sin0-dely*cos0;
00536   double para = delx*cos0+dely*sin0;
00537   double tand = parvec[tanDipIndex];
00538   double oldphi  = parvec[phi0Index] +
00539     fltlen*parvec[omegaIndex]/sqrt(1.+tand*tand);
00540 // delta
00541   double newdelta2 = delta*delta + delx*delx + dely*dely +
00542     2.0*delta*perp;
00543 // assume delta, newdelta have the same sign
00544   double newdelta = delta>0 ? sqrt(newdelta2) : -sqrt(newdelta2);
00545   double invdelta = 1.0/newdelta;
00546   double invdelta2 = 1.0/newdelta2;
00547 // d0
00548   newvec[d0Index] = newdelta - rad;
00549 // phi0; check that we don't get the wrong wrapping. Atan2 has 2Pi ambiguity, not pi
00550   double newphi = atan2(sin0+delx/delta,cos0-dely/delta);
00551   while(fabs(newphi - oldphi)>M_PI)
00552     if(newphi > oldphi)
00553       newphi -= M_2PI;
00554     else
00555       newphi += M_2PI;
00556   newvec[phi0Index] = newphi;
00557   double delphi = newphi-parvec[phi0Index];
00558 //z0
00559   newvec[z0Index] += tand*rad*(delphi) - delz;
00560 // now covariance: first, compute the rotation matrix
00561 // start with 0: lots of terms are zero
00562   static HepMatrix covrot(NHLXPRM,NHLXPRM,0);
00563 //
00564 // omega is diagonal
00565   covrot(omegaIndex+1,omegaIndex+1) = 1.0;
00566 // tandip is diagonal
00567   covrot(tanDipIndex+1,tanDipIndex+1) = 1.0;
00568 // d0
00569   covrot(d0Index+1,omegaIndex+1) = rad2*(1.0 - invdelta*(delta + perp));
00570   covrot(d0Index+1,d0Index+1) = invdelta*(delta + perp);
00571   covrot(d0Index+1,phi0Index+1) = delta*para*invdelta;
00572 // phi0
00573   covrot(phi0Index+1,omegaIndex+1) = rad2*para*invdelta2;
00574   covrot(phi0Index+1,d0Index+1) = -para*invdelta2;
00575   covrot(phi0Index+1,phi0Index+1) = delta*(delta + perp)*invdelta2;
00576 // z0
00577   covrot(z0Index+1,omegaIndex+1) = tand*
00578     (rad*covrot(phi0Index+1,omegaIndex+1) - rad2*delphi);
00579   covrot(z0Index+1,d0Index+1) = tand*rad*covrot(phi0Index+1,d0Index+1);
00580   covrot(z0Index+1,phi0Index+1) = 
00581     tand*rad*(covrot(phi0Index+1,phi0Index+1) - 1.0);
00582   covrot(z0Index+1,tanDipIndex+1) = rad*delphi;
00583   covrot(z0Index+1,z0Index+1) = 1.0;
00584 //
00585 //  Apply the rotation
00586   newcov = oldcov.similarity(covrot);
00587 // done
00588 }

TranslateParams HelixTraj::paramFunction (  )  const [inline, virtual]

Implements TrkSimpTraj.

Definition at line 69 of file HelixTraj.h.

References paramFunc().

00069 { return HelixTraj::paramFunc; }

double HelixTraj::phi0 (  )  const

Definition at line 510 of file HelixTraj.cxx.

References TrkSimpTraj::parameters(), and phi0Index.

Referenced by angle(), getDFInfo(), and getDFInfo2().

00511 {
00512   return BesAngle(parameters()->parameter()[phi0Index]).rad();
00513 }

HepPoint3D HelixTraj::position ( double  fltLen  )  const [virtual]

Implements Trajectory.

Definition at line 93 of file HelixTraj.cxx.

References cos(), cosDip(), d0(), omega(), DifIndepPar::parameter(), TrkSimpTraj::parameters(), phi0Index, TrkSimpTraj::referencePoint(), sin(), tanDip(), x, z(), and z0().

00094 {
00095   double cDip = cosDip();
00096   double sDip = tanDip() * cDip;
00097   double phi00 = parameters()->parameter()[phi0Index];  // Don't normalize
00098   double ang = phi00 + cDip*f*omega();
00099   double cang = cos(ang);
00100   double sang = sin(ang);
00101   double sphi0 = sin(phi00);
00102   double cphi0 = cos(phi00);
00103 
00104   return HepPoint3D((sang - sphi0)/omega() - d0()*sphi0+referencePoint().x(),
00105                  -(cang - cphi0)/omega() + d0()*cphi0+referencePoint().y(),
00106                  z0() + f*sDip                       +referencePoint().z());
00107 }

virtual void HelixTraj::print ( std::ostream &  os  )  const [virtual]

Reimplemented from TrkSimpTraj.

virtual void HelixTraj::printAll ( std::ostream &  os  )  const [virtual]

Reimplemented from TrkSimpTraj.

double Trajectory::range (  )  const [inline, inherited]

Definition at line 93 of file Trajectory.h.

References Trajectory::hiRange(), and Trajectory::lowRange().

Referenced by TrkDifPieceTraj::append(), TrkSimpTraj::invert(), TrkDifPieceTraj::invert(), and TrkDifPieceTraj::prepend().

00093 { return hiRange()-lowRange(); }

const HepPoint3D& TrkSimpTraj::referencePoint (  )  const [inline, inherited]

Definition at line 84 of file TrkSimpTraj.h.

References TrkSimpTraj::_refpoint.

Referenced by TrkDifLineTraj::getDFInfo(), TrkCircleTraj::getDFInfo(), getDFInfo(), TrkCircleTraj::getDFInfo2(), getDFInfo2(), TrkCircleTraj::getInfo(), getInfo(), TrkDifLineTraj::position(), TrkCircleTraj::position(), position(), TrkDifLineTraj::x(), TrkCircleTraj::x(), TrkDifLineTraj::y(), TrkCircleTraj::y(), TrkDifLineTraj::z(), and z().

00084 {return _refpoint;}

void Trajectory::setFlightRange ( double  newrange[2]  )  [virtual, inherited]

Reimplemented in TrkDifPieceTraj.

Definition at line 57 of file Trajectory.cxx.

References Trajectory::flightrange.

Referenced by TrkDifPieceTraj::append(), TrkSimpTraj::changePoint(), TrkSimpTraj::invert(), TrkDifPieceTraj::invert(), TrkDifPieceTraj::prepend(), and TrkDifPieceTraj::TrkDifPieceTraj().

00058 {
00059   if (newrange[1] >= newrange[0]) {
00060     flightrange[0] = newrange[0];
00061     flightrange[1] = newrange[1];
00062   } else {
00063     std::cout<<"ErrMsg(error) "<< "Invalid Trajectory range requested." << std::endl;
00064     flightrange[0] = newrange[1];
00065     flightrange[1] = newrange[0];
00066   }
00067 }

void TrkSimpTraj::setPoint ( const HepPoint3D &  newpoint  )  [inline, inherited]

Definition at line 96 of file TrkSimpTraj.h.

References TrkSimpTraj::_refpoint.

00096 {_refpoint = newpoint;}

double HelixTraj::sinDip (  )  const [inline, private]

Definition at line 106 of file HelixTraj.h.

References cosDip(), and tanDip().

Referenced by derivDisplace(), and z().

00106 {return tanDip()*cosDip(); }

double HelixTraj::tanDip (  )  const [inline]

Definition at line 83 of file HelixTraj.h.

References DifIndepPar::parameter(), TrkSimpTraj::parameters(), and tanDipIndex.

Referenced by cosDip(), derivDeflect(), derivDisplace(), derivPFract(), dip(), direction(), distTo1stError(), distTo2ndError(), getDFInfo(), getDFInfo2(), getInfo(), position(), and sinDip().

00083 {  return parameters()->parameter()[tanDipIndex]; }

double HelixTraj::translen ( const double &  f  )  const [inline, private]

Definition at line 107 of file HelixTraj.h.

References cosDip().

Referenced by arc(), derivDeflect(), and derivPFract().

00107 {return cosDip()*f;}

bool Trajectory::validFlightDistance ( double  f,
double  tolerance = 0.0 
) const [inline, inherited]

Definition at line 88 of file Trajectory.h.

References Trajectory::flightrange.

Referenced by TrkDifPieceTraj::trajIndex().

00088                                                                      {
00089   return f >= flightrange[0]-tol && f <= flightrange[1]+tol; 
00090 }

void HelixTraj::visitAccept ( TrkVisitor *  vis  )  const [virtual]

Implements TrkSimpTraj.

Definition at line 591 of file HelixTraj.cxx.

References TrkVisitor::trkVisitHelixTraj().

00592 {
00593 // Visitor access--just use the Visitor class member function
00594   vis->trkVisitHelixTraj(this);
00595 }

double HelixTraj::z ( const double &   )  const [private]

Definition at line 87 of file HelixTraj.cxx.

References TrkSimpTraj::referencePoint(), sinDip(), and z0().

Referenced by getDFInfo(), getDFInfo2(), and position().

00088 {
00089   return z0() + f*sinDip() + referencePoint().z();
00090 }

double HelixTraj::z0 (  )  const [inline]

Definition at line 82 of file HelixTraj.h.

References DifIndepPar::parameter(), TrkSimpTraj::parameters(), and z0Index.

Referenced by getDFInfo(), getDFInfo2(), getInfo(), position(), and z().

00082 {return parameters()->parameter()[z0Index]; }

Member Data Documentation

TrkParams TrkSimpTraj::_dtparams [protected, inherited]

Definition at line 117 of file TrkSimpTraj.h.

Referenced by NeutTraj::_np(), TrkSimpTraj::changePoint(), TrkDifLineTraj::operator=(), TrkCircleTraj::operator=(), NeutTraj::operator=(), operator=(), TrkSimpTraj::operator==(), and TrkSimpTraj::parameters().

HepPoint3D TrkSimpTraj::_refpoint [protected, inherited]

Definition at line 118 of file TrkSimpTraj.h.

Referenced by TrkSimpTraj::changePoint(), TrkDifLineTraj::operator=(), TrkCircleTraj::operator=(), operator=(), TrkSimpTraj::operator==(), TrkSimpTraj::referencePoint(), and TrkSimpTraj::setPoint().

HepPoint3D TrkSimpTraj::_theOrigin [static, inherited]

Definition at line 59 of file TrkSimpTraj.h.

double Trajectory::flightrange[2] [protected, inherited]

Definition at line 83 of file Trajectory.h.

Referenced by TrkDifPieceTraj::append(), Trajectory::hiRange(), Trajectory::lowRange(), TrkDifPieceTraj::operator=(), NeutTraj::operator=(), Trajectory::operator=(), MdcSagTraj::operator=(), TrkDifPieceTraj::prepend(), TrkDifPieceTraj::resize(), TrkDifPieceTraj::setFlightRange(), Trajectory::setFlightRange(), Trajectory::Trajectory(), TrkDifPieceTraj::TrkDifPieceTraj(), and Trajectory::validFlightDistance().

Generated on Tue Nov 29 23:19:39 2016 for BOSS_7.0.2 by  doxygen 1.4.7