RKTrackRep Class Reference

Track Representation module based on a Runge-Kutta algorithm including a full material model. More...

#include <RKTrackRep.h>

Inheritance diagram for RKTrackRep:

Public Member Functions
	RKTrackRep ()
	RKTrackRep (const TVector3 &pos, const TVector3 &mom, const TVector3 &poserr, const TVector3 &momerr, const int &PDGCode)
	RKTrackRep (const GFTrackCand *aGFTrackCandPtr)
	RKTrackRep (const TVector3 &pos, const TVector3 &mom, const int &PDGCode)
	RKTrackRep (const GFDetPlane &pl, const TVector3 &mom, const int &PDGCode)
virtual	~RKTrackRep ()
virtual GFAbsTrackRep *	clone () const
virtual GFAbsTrackRep *	prototype () const
double	extrapolate (const GFDetPlane &, TMatrixT< double > &statePred, TMatrixT< double > &covPred)
	returns the tracklength spanned in this extrapolation More...
double	extrapolate (const GFDetPlane &, TMatrixT< double > &statePred)
	returns the tracklength spanned in this extrapolation More...
void	extrapolateToPoint (const TVector3 &pos, TVector3 &poca, TVector3 &dirInPoca)
	This method is to extrapolate the track to point of closest approach to a point in space. More...
void	extrapolateToLine (const TVector3 &point1, const TVector3 &point2, TVector3 &poca, TVector3 &dirInPoca, TVector3 &poca_onwire)
	This method extrapolates to the point of closest approach to a line. More...
double	stepalong (double h, TVector3 &point, TVector3 &dir)
	make step of h cm along the track, returns the tracklength spanned in this extrapolation More...
TVector3	getPos (const GFDetPlane &)
	Returns position of the track in the plane. More...
TVector3	getMom (const GFDetPlane &)
	Returns momentum of the track in the plane. More...
void	getPosMom (const GFDetPlane &, TVector3 &pos, TVector3 &mom)
	Gets position and momentum in the plane. More...
double	getCharge () const
	Returns charge. More...
int	getPDG ()
void	switchDirection ()
	deprecated More...
void	setPDG (int)
	Set PDG particle code. More...
void	setData (const TMatrixT< double > &st, const GFDetPlane &pl, const TMatrixT< double > *cov=NULL, const TMatrixT< double > *aux=NULL)
	Sets state, plane and (optionally) covariance. More...
const TMatrixT< double > *	getAuxInfo (const GFDetPlane &pl)
	Get auxillary information from the track representation. More...
bool	hasAuxInfo ()
	See if the track representation has auxillary information stored. More...
void	getPosMomCov (const GFDetPlane &pl, TVector3 &pos, TVector3 &mom, TMatrixT< double > &cov)
	method which gets position, momentum and 6x6 covariance matrix More...
double	extrapolate (const GFDetPlane &plane)
	This changes the state and cov and plane of the rep. More...
unsigned int	getDim () const
	returns dimension of state vector More...
virtual void	Print () const
TMatrixT< double >	getState () const
TMatrixT< double >	getCov () const
double	getStateElem (int i) const
double	getCovElem (int i, int j) const
TVector3	getPos ()
TVector3	getMom ()
void	getPosMomCov (TVector3 &pos, TVector3 &mom, TMatrixT< double > &c)
TMatrixT< double >	getFirstState () const
TMatrixT< double >	getFirstCov () const
GFDetPlane	getFirstPlane () const
TMatrixT< double >	getLastState () const
TMatrixT< double >	getLastCov () const
GFDetPlane	getLastPlane () const
double	getChiSqu () const
double	getRedChiSqu () const
	returns chi2/ndf More...
unsigned int	getNDF () const
void	setCov (const TMatrixT< double > &aCov)
void	setFirstState (const TMatrixT< double > &aState)
void	setFirstCov (const TMatrixT< double > &aCov)
void	setFirstPlane (const GFDetPlane &aPlane)
void	setLastState (const TMatrixT< double > &aState)
void	setLastCov (const TMatrixT< double > &aCov)
void	setLastPlane (const GFDetPlane &aPlane)
const GFDetPlane &	getReferencePlane () const
void	setChiSqu (double aChiSqu)
void	setNDF (unsigned int n)
void	addChiSqu (double aChiSqu)
void	addNDF (unsigned int n)
void	setStatusFlag (int _val)
bool	setInverted (bool f=true)
	Deprecated. Should be removed soon. More...
bool	getStatusFlag ()
virtual void	reset ()

Protected Attributes
unsigned int	fDimension
	Dimensionality of track representation. More...
TMatrixT< double >	fState
	The vector of track parameters. More...
TMatrixT< double >	fCov
	The covariance matrix. More...
double	fChiSqu
	chiSqu of the track fit More...
unsigned int	fNdf
int	fStatusFlag
	status of track representation: 0 means everything's OK More...
bool	fInverted
	specifies the direction of flight of the particle More...
TMatrixT< double >	fFirstState
	state, cov and plane for first and last point in fit More...
TMatrixT< double >	fFirstCov
TMatrixT< double >	fLastState
TMatrixT< double >	fLastCov
GFDetPlane	fFirstPlane
GFDetPlane	fLastPlane
GFDetPlane	fRefPlane

Private Member Functions
RKTrackRep &	operator= (const RKTrackRep *)
bool	RKutta (const GFDetPlane &plane, double *P, double &coveredDistance, std::vector< TVector3 > &points, std::vector< double > &pointLengths, const double &maxLen=-1, bool calcCov=true) const
	Propagates the particle through the magnetic field. More...
TVector3	poca2Line (const TVector3 &extr1, const TVector3 &extr2, const TVector3 &point) const
double	Extrap (const GFDetPlane &plane, TMatrixT< double > *state, TMatrixT< double > *cov=NULL) const
	Handles propagation and material effects. More...

Private Attributes
bool	fDirection
int	fPdg
	PDG particle code. More...
double	fMass
	Mass (in GeV) More...
double	fCharge
	Charge. More...
GFDetPlane	fCachePlane
double	fCacheSpu
double	fSpu
TMatrixT< double >	fAuxInfo

Detailed Description

Track Representation module based on a Runge-Kutta algorithm including a full material model.

Author

Christian Höppner (Technische Universität München, original author)

Johannes Rauch (Technische Universität München, author)

The Runge Kutta implementation stems from GEANT3 originally (R. Brun et al.). Porting to C goes back to Igor Gavrilenko @ CERN. The code was taken from the Phast analysis package of the COMPASS experiment (Sergei Gerrassimov @ CERN).

Definition at line 49 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Constructor & Destructor Documentation

RKTrackRep::RKTrackRep

(

)

Definition at line 74 of file RKTrackRep.cxx.

Referenced by clone(), and prototype().

                       : GFAbsTrackRep(5), fDirection(true), fPdg(0), fMass(0.), fCharge(-1), fCachePlane(), fCacheSpu(1), fSpu(1), fAuxInfo(1,1) {
}

RKTrackRep::RKTrackRep	(	const TVector3 &	pos,
		const TVector3 &	mom,
		const TVector3 &	poserr,
		const TVector3 &	momerr,
		const int &	PDGCode
	)

Definition at line 78 of file RKTrackRep.cxx.

References fCharge, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), GFDetPlane::setNormal(), GFDetPlane::setO(), setPDG(), and v.

                                           :
                       GFAbsTrackRep(5), fDirection(true), fCachePlane(), fCacheSpu(1), fAuxInfo(1,1) {
  setPDG(PDGCode); // also sets charge and mass
                         

  fRefPlane.setO(pos);
  fRefPlane.setNormal(mom);

  fState[0][0]=fCharge/mom.Mag();
  //u' and v'
  fState[1][0]=0.0;
  fState[2][0]=0.0;
  //u and v
  fState[3][0]=0.0;
  fState[4][0]=0.0;
  //spu
  fSpu=1.;

  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);
  double pu=0.;
  double pv=0.;
  double pw=mom.Mag();

  fCov[3][3] = poserr.X()*poserr.X() * u.X()*u.X() +
               poserr.Y()*poserr.Y() * u.Y()*u.Y() +
               poserr.Z()*poserr.Z() * u.Z()*u.Z();
  fCov[4][4] = poserr.X()*poserr.X() * v.X()*v.X() +
               poserr.Y()*poserr.Y() * v.Y()*v.Y() +
               poserr.Z()*poserr.Z() * v.Z()*v.Z();
  fCov[0][0] = fCharge*fCharge/pow(mom.Mag(),6.) * 
               (mom.X()*mom.X() * momerr.X()*momerr.X()+
                mom.Y()*mom.Y() * momerr.Y()*momerr.Y()+
                mom.Z()*mom.Z() * momerr.Z()*momerr.Z());
  fCov[1][1] = pow((u.X()/pw - w.X()*pu/(pw*pw)),2.)*momerr.X()*momerr.X() +
               pow((u.Y()/pw - w.Y()*pu/(pw*pw)),2.)*momerr.Y()*momerr.Y() +
               pow((u.Z()/pw - w.Z()*pu/(pw*pw)),2.)*momerr.Z()*momerr.Z();
  fCov[2][2] = pow((v.X()/pw - w.X()*pv/(pw*pw)),2.)*momerr.X()*momerr.X() +
               pow((v.Y()/pw - w.Y()*pv/(pw*pw)),2.)*momerr.Y()*momerr.Y() +
               pow((v.Z()/pw - w.Z()*pv/(pw*pw)),2.)*momerr.Z()*momerr.Z();

}

RKTrackRep::RKTrackRep

(

const GFTrackCand *

aGFTrackCandPtr

)

Definition at line 128 of file RKTrackRep.cxx.

References fCharge, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFTrackCand::getDirError(), GFTrackCand::getDirSeed(), GFDetPlane::getO(), GFTrackCand::getPdgCode(), GFTrackCand::getPosError(), GFTrackCand::getPosSeed(), GFDetPlane::getU(), GFDetPlane::getV(), mom, GFDetPlane::setNormal(), GFDetPlane::setO(), setPDG(), and v.

                                                         :
                       GFAbsTrackRep(5), fDirection(true), fCachePlane(), fCacheSpu(1), fAuxInfo(1,1) {
  setPDG(aGFTrackCandPtr->getPdgCode()); // also sets charge and mass

  TVector3 mom = aGFTrackCandPtr->getDirSeed();
  fRefPlane.setO(aGFTrackCandPtr->getPosSeed());
  fRefPlane.setNormal(mom);
  double pw=mom.Mag();
  fState[0][0]=fCharge/pw;
  //u' and v'
  fState[1][0]=0.0;
  fState[2][0]=0.0;
  //u and v
  fState[3][0]=0.0;
  fState[4][0]=0.0;
  //spu
  fSpu=1.;

  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);
  double pu=0.;
  double pv=0.;

  TVector3 poserr = aGFTrackCandPtr->getPosError();
  TVector3 momerr = aGFTrackCandPtr->getDirError();
  fCov[3][3] = poserr.X()*poserr.X() * u.X()*u.X() +
               poserr.Y()*poserr.Y() * u.Y()*u.Y() +
               poserr.Z()*poserr.Z() * u.Z()*u.Z();
  fCov[4][4] = poserr.X()*poserr.X() * v.X()*v.X() +
               poserr.Y()*poserr.Y() * v.Y()*v.Y() +
               poserr.Z()*poserr.Z() * v.Z()*v.Z();
  fCov[0][0] = fCharge*fCharge/pow(mom.Mag(),6.) *
               (mom.X()*mom.X() * momerr.X()*momerr.X()+
                mom.Y()*mom.Y() * momerr.Y()*momerr.Y()+
                mom.Z()*mom.Z() * momerr.Z()*momerr.Z());
  fCov[1][1] = pow((u.X()/pw - w.X()*pu/(pw*pw)),2.)*momerr.X()*momerr.X() +
               pow((u.Y()/pw - w.Y()*pu/(pw*pw)),2.)*momerr.Y()*momerr.Y() +
               pow((u.Z()/pw - w.Z()*pu/(pw*pw)),2.)*momerr.Z()*momerr.Z();
  fCov[2][2] = pow((v.X()/pw - w.X()*pv/(pw*pw)),2.)*momerr.X()*momerr.X() +
               pow((v.Y()/pw - w.Y()*pv/(pw*pw)),2.)*momerr.Y()*momerr.Y() +
               pow((v.Z()/pw - w.Z()*pv/(pw*pw)),2.)*momerr.Z()*momerr.Z();

}

RKTrackRep::RKTrackRep	(	const TVector3 &	pos,
		const TVector3 &	mom,
		const int &	PDGCode
	)

Definition at line 174 of file RKTrackRep.cxx.

References fCharge, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), GFDetPlane::setNormal(), GFDetPlane::setO(), setPDG(), and v.

                                           :
                       GFAbsTrackRep(5),fDirection(true), fCachePlane(), fCacheSpu(1), fAuxInfo(1,1){
  setPDG(PDGCode); // also sets charge and mass
                         

  fRefPlane.setO(pos);
  fRefPlane.setNormal(mom);

  fState[0][0]=fCharge/mom.Mag();
  //u' and v'
  fState[1][0]=0.0;
  fState[2][0]=0.0;
  //u and v
  fState[3][0]=0.0;
  fState[4][0]=0.0;
  //spu
  fSpu=1.;

  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);
  double pu=0.;
  double pv=0.;
  double pw=mom.Mag();

  static const TVector3 stdPosErr(1.,1.,1.);
  static const TVector3 stdMomErr(1.,1.,1.);

  fCov[3][3] = stdPosErr.X()*stdPosErr.X() * u.X()*u.X() +
               stdPosErr.Y()*stdPosErr.Y() * u.Y()*u.Y() +
               stdPosErr.Z()*stdPosErr.Z() * u.Z()*u.Z();
  fCov[4][4] = stdPosErr.X()*stdPosErr.X() * v.X()*v.X() +
               stdPosErr.Y()*stdPosErr.Y() * v.Y()*v.Y() +
               stdPosErr.Z()*stdPosErr.Z() * v.Z()*v.Z();
  fCov[0][0] = fCharge*fCharge/pow(mom.Mag(),6.) * 
               (mom.X()*mom.X() * stdMomErr.X()*stdMomErr.X()+
                mom.Y()*mom.Y() * stdMomErr.Y()*stdMomErr.Y()+
                mom.Z()*mom.Z() * stdMomErr.Z()*stdMomErr.Z());
  fCov[1][1] = pow((u.X()/pw - w.X()*pu/(pw*pw)),2.)*stdMomErr.X()*stdMomErr.X() +
               pow((u.Y()/pw - w.Y()*pu/(pw*pw)),2.)*stdMomErr.Y()*stdMomErr.Y() +
               pow((u.Z()/pw - w.Z()*pu/(pw*pw)),2.)*stdMomErr.Z()*stdMomErr.Z();
  fCov[2][2] = pow((v.X()/pw - w.X()*pv/(pw*pw)),2.)*stdMomErr.X()*stdMomErr.X() +
               pow((v.Y()/pw - w.Y()*pv/(pw*pw)),2.)*stdMomErr.Y()*stdMomErr.Y() +
               pow((v.Z()/pw - w.Z()*pv/(pw*pw)),2.)*stdMomErr.Z()*stdMomErr.Z();

}

RKTrackRep::RKTrackRep	(	const GFDetPlane &	pl,
		const TVector3 &	mom,
		const int &	PDGCode
	)

Definition at line 224 of file RKTrackRep.cxx.

References fCharge, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), setPDG(), and v.

                                           :
                       GFAbsTrackRep(5),fDirection(true), fCachePlane(), fCacheSpu(1), fAuxInfo(1,1){
  setPDG(PDGCode); // also sets charge and mass
                         

  fRefPlane = pl;
  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);

  double pu=mom*u;
  double pv=mom*v;
  double pw=mom*w;

  fState[0][0]=fCharge/mom.Mag();
  //u' and v'
  fState[1][0]=pu/pw;
  fState[2][0]=pv/pw;
  //u and v
  fState[3][0]=0.0;
  fState[4][0]=0.0;
  //spu
  fSpu=1.;

  static const TVector3 stdPosErr2(1.,1.,1.);
  static const TVector3 stdMomErr2(1.,1.,1.);

  fCov[3][3] = stdPosErr2.X()*stdPosErr2.X() * u.X()*u.X() +
               stdPosErr2.Y()*stdPosErr2.Y() * u.Y()*u.Y() +
               stdPosErr2.Z()*stdPosErr2.Z() * u.Z()*u.Z();
  fCov[4][4] = stdPosErr2.X()*stdPosErr2.X() * v.X()*v.X() +
               stdPosErr2.Y()*stdPosErr2.Y() * v.Y()*v.Y() +
               stdPosErr2.Z()*stdPosErr2.Z() * v.Z()*v.Z();
  fCov[0][0] = fCharge*fCharge/pow(mom.Mag(),6.) * 
               (mom.X()*mom.X() * stdMomErr2.X()*stdMomErr2.X()+
                mom.Y()*mom.Y() * stdMomErr2.Y()*stdMomErr2.Y()+
                mom.Z()*mom.Z() * stdMomErr2.Z()*stdMomErr2.Z());
  fCov[1][1] = pow((u.X()/pw - w.X()*pu/(pw*pw)),2.)*stdMomErr2.X()*stdMomErr2.X() +
               pow((u.Y()/pw - w.Y()*pu/(pw*pw)),2.)*stdMomErr2.Y()*stdMomErr2.Y() +
               pow((u.Z()/pw - w.Z()*pu/(pw*pw)),2.)*stdMomErr2.Z()*stdMomErr2.Z();
  fCov[2][2] = pow((v.X()/pw - w.X()*pv/(pw*pw)),2.)*stdMomErr2.X()*stdMomErr2.X() +
               pow((v.Y()/pw - w.Y()*pv/(pw*pw)),2.)*stdMomErr2.Y()*stdMomErr2.Y() +
               pow((v.Z()/pw - w.Z()*pv/(pw*pw)),2.)*stdMomErr2.Z()*stdMomErr2.Z();

}

RKTrackRep::~RKTrackRep ( )

virtual

Definition at line 69 of file RKTrackRep.cxx.

                       {
  //GFMaterialEffects is now a Singleton
}

Member Function Documentation

void GFAbsTrackRep::addChiSqu ( double  aChiSqu )

inlineinherited

Definition at line 303 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fChiSqu.

Referenced by GFKalman::processHit().

                                        {
    fChiSqu += aChiSqu;
  }

void GFAbsTrackRep::addNDF ( unsigned int  n )

inlineinherited

Definition at line 306 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fNdf, and n.

Referenced by GFKalman::processHit().

                                     {
    fNdf += n;
  }

virtual GFAbsTrackRep* RKTrackRep::clone ( ) const

inlinevirtual

Implements GFAbsTrackRep.

Definition at line 74 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

References RKTrackRep().

{return new RKTrackRep(*this);}

double RKTrackRep::Extrap ( const GFDetPlane &  plane, TMatrixT< double > *  state, TMatrixT< double > *  cov = NULL  ) const

private

Handles propagation and material effects.

extrapolate(), extrapolateToPoint() and extrapolateToLine() call this function. Extrap() needs a plane as an argument, hence extrapolateToPoint() and extrapolateToLine() create virtual detector planes. In this function, RKutta() is called and the resulting points and point paths are filtered so that the direction doesn't change and tiny steps are filtered out. After the propagation the material effects in #fEffect are called. Extrap() will loop until the plane is reached, unless the propagation fails or the maximum number of iterations is exceeded.

Definition at line 991 of file RKTrackRep.cxx.

References GFDetPlane::dist(), GFDetPlane::distance(), GFMaterialEffects::effects(), fabs(), fCharge, fPdg, GFMaterialEffects::getInstance(), i, GFDetPlane::inActive(), MINSTEP, noise, P, RKutta(), and GFException::setFatal().

Referenced by extrapolate(), extrapolateToLine(), extrapolateToPoint(), and stepalong().

                                                                                                        {

  static const int maxNumIt(2000);
  int numIt(0);
  bool calcCov(true);
  if(cov==NULL) calcCov=false;  

  double *P;
  if(calcCov) {P = new double[56]; memset(P,0x00,56*sizeof(double));}
  else {P = new double[7];} // not needed memset(P,0x00,7*sizeof(double));};

  for(int i=0;i<7;++i){
    P[i] = (*state)[i][0];
  }
  
  TMatrixT<double> jac(7,7);
  TMatrixT<double> jacT(7,7);
  TMatrixT<double> oldCov(7,7);
  if(calcCov) oldCov=(*cov);
  double coveredDistance(0.);
  double sumDistance(0.);

  while(true){
    if(numIt++ > maxNumIt){
      GFException exc("RKTrackRep::Extrap ==> maximum number of iterations exceeded",
                      __LINE__,__FILE__);
      exc.setFatal();
      delete[] P;
      throw exc;
    }

    if(calcCov){
      memset(&P[7],0x00,49*sizeof(double));
      for(int i=0; i<6; ++i){
        P[(i+1)*7+i] = 1.;
      }
      P[55] =  (*state)[6][0];
    }

    //double dir(1.); //[R.K. 01/2017] unused variable?
    {
      TVector3 Pvect(P[0],P[1],P[2]); //position
      TVector3 Avect(P[3],P[4],P[5]); //direction
      TVector3 dist = plane.dist(Pvect); //from point to plane
      //if(dist*Avect<0.) dir=-1.; //[R.K. 01/2017] unused variable?
    }

    TVector3 directionBefore(P[3],P[4],P[5]); // direction before propagation
    directionBefore.SetMag(1.);
    
    // propagation
    std::vector<TVector3> points;
    std::vector<double> pointPaths;
    if( ! this->RKutta(plane, P, coveredDistance, points, pointPaths, -1., calcCov) ) { // maxLen currently not used
      GFException exc("RKTrackRep::Extrap ==> Runge Kutta propagation failed",__LINE__,__FILE__);
      exc.setFatal(); // stops propagation; faster, but some hits will be lost
      delete[] P;
      throw exc;
    }

    TVector3 directionAfter(P[3],P[4],P[5]); // direction after propagation
    directionAfter.SetMag(1.);
      
    sumDistance+=coveredDistance;
     
    // filter Points
    std::vector<TVector3> pointsFilt(1, points.at(0));
    std::vector<double> pointPathsFilt(1, 0.);
    // only if in right direction
    for(unsigned int i=1;i<points.size();++i){ 
      if (pointPaths.at(i) * coveredDistance > 0.) { 
        pointsFilt.push_back(points.at(i));
        pointPathsFilt.push_back(pointPaths.at(i));
      }
      else {
        pointsFilt.back() = points.at(i);
        pointPathsFilt.back() += pointPaths.at(i);
      }
      // clean up tiny steps
      int position = pointsFilt.size()-1;  // position starts with 0
      if (fabs(pointPathsFilt.back()) < MINSTEP && position > 1) {
        pointsFilt.at(position-1) = pointsFilt.at(position);
        pointsFilt.pop_back();        
        pointPathsFilt.at(position-1) += pointPathsFilt.at(position);
        pointPathsFilt.pop_back();
      }
    }
    
    //consistency check
    double checkSum(0.);
    for(unsigned int i=0;i<pointPathsFilt.size();++i){
      checkSum+=pointPathsFilt.at(i);
    }
    if(fabs(checkSum-coveredDistance)>1.E-7){
      GFException exc("RKTrackRep::Extrap ==> fabs(checkSum-coveredDistance)>1.E-7",__LINE__,__FILE__);
      exc.setFatal();
      delete[] P;
      throw exc;
    }
    
    if(calcCov){ //calculate Jacobian jac
      for(int i=0;i<7;++i){
              for(int j=0;j<7;++j){
                if(i<6) jac[i][j] = P[ (i+1)*7+j ];
                else jac[i][j] = P[ (i+1)*7+j ]/P[6];
              }  
      }
      jacT = jac;
      jacT.T();
    }
    
    TMatrixT<double> noise(7,7); // zero everywhere by default
    
    // call MatEffects
    double momLoss; // momLoss has a sign - negative loss means momentum gain
    
    momLoss = GFMaterialEffects::getInstance()->effects(pointsFilt,
                               pointPathsFilt,
                               fabs(fCharge/P[6]), // momentum
                               fPdg,
                               calcCov,
                               &noise,
                               &jac,
                               &directionBefore,
                               &directionAfter);
  
    if(fabs(P[6])>1.E-10){ // do momLoss only for defined 1/momentum .ne.0      
            P[6] = fCharge/(fabs(fCharge/P[6])-momLoss);
    }
    
    if(calcCov){ //propagate cov and add noise
      if(!(oldCov < 1.E200)){
        GFException exc("RKTrackRep::Extrap ==> covariance matrix exceeds numerical limits",__LINE__,__FILE__);
        exc.setFatal();
        delete[] P;
        throw exc;
      }
      oldCov = *cov;
      *cov = jacT*((oldCov)*jac)+noise;
    }
    
    
    //we arrived at the destination plane, if we point to the active area
    //of the plane (if it is finite), and the distance is below threshold
    if( plane.inActive(TVector3(P[0],P[1],P[2]),TVector3(P[3],P[4],P[5]))) {
      if(plane.distance(P[0],P[1],P[2])<MINSTEP) break;
    }
  }
  (*state)[0][0] = P[0];  (*state)[1][0] = P[1];
  (*state)[2][0] = P[2];  (*state)[3][0] = P[3];
  (*state)[4][0] = P[4];  (*state)[5][0] = P[5];
  (*state)[6][0] = P[6];
    
  delete[] P;
  return sumDistance;
}

double RKTrackRep::extrapolate ( const GFDetPlane &  pl, TMatrixT< double > &  statePred, TMatrixT< double > &  covPred  )

virtual

returns the tracklength spanned in this extrapolation

The covariance matrix is transformed from the plane coordinate system to the master reference system (for the propagation) and, after propagation, back to the plane coordinate system.
Also the parameter spu (which is +1 or -1 and indicates the direction of the particle) is calculated and stored in fCacheSpu. The plane is stored in fCachePlane.
Master reference system (MARS):

\begin{eqnarray*}x & = & O_{x}+uU_{x}+vV_{x}\\y & = & O_{y}+uU_{y}+vV_{y}\\z & = & O_{z}+uU_{z}+vV_{z}\\a_{x} & = & \frac{\mbox{spu}}{\widetilde{p}}\left(N_{x}+u\prime U_{x}+v\prime V_{x}\right)\\a_{y} & = & \frac{\mbox{spu}}{\widetilde{p}}\left(N_{y}+u\prime U_{y}+v\prime V_{y}\right)\\a_{z} & = & \frac{\mbox{spu}}{\widetilde{p}}\left(N_{z}+u\prime U_{z}+v\prime V_{z}\right)\\\frac{q}{p} & = & \frac{q}{p}\end{eqnarray*}

Plane coordinate system:

\begin{eqnarray*}u & = & \left(x-O_{x}\right)U_{x}+\left(y-O_{y}\right)U_{y}+\left(z-O_{z}\right)U_{z}\\v & = & \left(x-O_{x}\right)U_{x}+\left(y-O_{y}\right)U_{y}+\left(z-O_{z}\right)U_{z}\\u\prime & = & \frac{a_{x}U_{x}+a_{y}U_{y}+a_{z}U_{z}}{a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}}\\v\prime & = & \frac{a_{x}V_{x}+a_{y}V_{y}+a_{z}V_{z}}{a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}}\\\frac{q}{p} & = & \frac{q}{p}\\\mbox{spu} & = & \frac{a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}}{|a_{x}^{2}N_{x}^{2}+a_{y}^{2}N_{y}^{2}+a_{z}^{2}N_{z}^{2}|}=\pm1\end{eqnarray*}

Jacobians:
\(J_{p,M}=\left(\begin{array}{ccccc}\frac{\partial x}{\partial u} & \frac{\partial x}{\partial v} & \frac{\partial x}{\partial u\prime} & \frac{\partial x}{\partial v\prime} & \frac{\partial x}{\partial\frac{q}{p}}\\\frac{\partial y}{\partial u} & \frac{\partial y}{\partial v} & \frac{\partial y}{\partial u\prime} & \frac{\partial y}{\partial v\prime} & \frac{\partial y}{\partial\frac{q}{p}}\\\frac{\partial z}{\partial u} & \frac{\partial z}{\partial v} & \frac{\partial z}{\partial u\prime} & \frac{\partial z}{\partial v\prime} & \frac{\partial z}{\partial\frac{q}{p}}\\\frac{\partial a_{x}}{\partial u} & \frac{\partial a_{x}}{\partial v} & \frac{\partial a_{x}}{\partial u\prime} & \frac{\partial a_{x}}{\partial v\prime} & \frac{\partial a_{x}}{\partial\frac{q}{p}}\\\frac{\partial a_{y}}{\partial u} & \frac{\partial a_{y}}{\partial v} & \frac{\partial a_{y}}{\partial u\prime} & \frac{\partial a_{y}}{\partial v\prime} & \frac{\partial a_{y}}{\partial\frac{q}{p}}\\\frac{\partial a_{z}}{\partial u} & \frac{\partial a_{z}}{\partial v} & \frac{\partial a_{z}}{\partial u\prime} & \frac{\partial a_{z}}{\partial v\prime} & \frac{\partial a_{z}}{\partial\frac{q}{p}}\\\frac{\partial\frac{q}{p}}{\partial u} & \frac{\partial\frac{q}{p}}{\partial v} & \frac{\partial\frac{q}{p}}{\partial u\prime} & \frac{\partial\frac{q}{p}}{\partial v\prime} & \frac{\partial\frac{q}{p}}{\partial\frac{q}{p}}\end{array}\right)\)

\(J_{p,M}=\left(\begin{array}{cccccc}U_{x} & V_{x} & 0 & 0 & 0\\U_{y} & V_{y} & 0 & 0 & 0\\U_{z} & V_{z} & 0 & 0 & 0\\0 & 0 & \left\{ \frac{\textrm{spu}}{\widetilde{p}}U_{x}-\left[\frac{\textrm{spu}}{\widetilde{p}^{3}}\widetilde{p}_{x}\left(U_{x}\widetilde{p}_{x}+U_{y}\widetilde{p}_{y}+U_{z}\widetilde{p}_{z}\right)\right]\right\} & \left\{ \frac{\textrm{spu}}{\widetilde{p}}V_{x}-\left[\frac{\textrm{spu}}{\widetilde{p}^{3}}\widetilde{p}_{x}\left(V_{x}\widetilde{p}_{x}+V_{y}\widetilde{p}_{y}+V_{z}\widetilde{p}_{z}\right)\right]\right\} & 0\\0 & 0 & \left\{ \frac{\textrm{spu}}{\widetilde{p}}U_{y}-\left[\frac{\textrm{spu}}{\widetilde{p}^{3}}\widetilde{p}_{y}\left(U_{x}\widetilde{p}_{x}+U_{y}\widetilde{p}_{y}+U_{z}\widetilde{p}_{z}\right)\right]\right\} & \left\{ \frac{\textrm{spu}}{\widetilde{p}}V_{y}-\left[\frac{\textrm{spu}}{\widetilde{p}^{3}}\widetilde{p}_{y}\left(V_{x}\widetilde{p}_{x}+V_{y}\widetilde{p}_{y}+V_{z}\widetilde{p}_{z}\right)\right]\right\} & 0\\0 & 0 & \left\{ \frac{\textrm{spu}}{\widetilde{p}}U_{z}-\left[\frac{\textrm{spu}}{\widetilde{p}^{3}}\widetilde{p}_{z}\left(U_{x}\widetilde{p}_{x}+U_{y}\widetilde{p}_{y}+U_{z}\widetilde{p}_{z}\right)\right]\right\} & \left\{ \frac{\textrm{spu}}{\widetilde{p}}V_{z}-\left[\frac{\textrm{spu}}{\widetilde{p}^{3}}\widetilde{p}_{z}\left(V_{x}\widetilde{p}_{x}+V_{y}\widetilde{p}_{y}+V_{z}\widetilde{p}_{z}\right)\right]\right\} & 0\\0 & 0 & 0 & 0 & 1\end{array}\right)\)

with

\begin{eqnarray*}\widetilde{p} & = & \sqrt{\widetilde{p}_{x}^{2}+\widetilde{p}_{y}^{2}+\widetilde{p}_{z}^{2}}\\\widetilde{p}_{x} & = & \textrm{spu}\left(N_{x}+u\prime U_{x}+v\prime V_{x}\right)\\\widetilde{p}_{y} & = & \textrm{spu}\left(N_{y}+u\prime U_{y}+v\prime V_{y}\right)\\\widetilde{p}_{z} & = & \textrm{spu}\left(N_{z}+u\prime U_{z}+v\prime V_{z}\right)\end{eqnarray*}

\(J_{M,p}=\left(\begin{array}{ccccccc}\frac{\partial u}{\partial x} & \frac{\partial u}{\partial y} & \frac{\partial u}{\partial z} & \frac{\partial u}{\partial a_{x}} & \frac{\partial u}{\partial a_{y}} & \frac{\partial u}{\partial a_{z}} & \frac{\partial u}{\partial\frac{q}{p}}\\\frac{\partial v}{\partial x} & \frac{\partial v}{\partial y} & \frac{\partial v}{\partial z} & \frac{\partial v}{\partial a_{x}} & \frac{\partial v}{\partial a_{y}} & \frac{\partial v}{\partial a_{z}} & \frac{\partial v}{\partial\frac{q}{p}}\\\frac{\partial u\prime}{\partial x} & \frac{\partial u\prime}{\partial y} & \frac{\partial u\prime}{\partial z} & \frac{\partial u\prime}{\partial a_{x}} & \frac{\partial u\prime}{\partial a_{y}} & \frac{\partial u\prime}{\partial a_{z}} & \frac{\partial u\prime}{\partial\frac{q}{p}}\\\frac{\partial v\prime}{\partial x} & \frac{\partial v\prime}{\partial y} & \frac{\partial v\prime}{\partial z} & \frac{\partial v\prime}{\partial a_{x}} & \frac{\partial v\prime}{\partial a_{y}} & \frac{\partial v\prime}{\partial a_{z}} & \frac{\partial v\prime}{\partial\frac{q}{p}}\\ \frac{\partial\frac{q}{p}}{\partial x} & \frac{\partial\frac{q}{p}}{\partial y} & \frac{\partial\frac{q}{p}}{\partial z} & \frac{\partial\frac{q}{p}}{\partial a_{x}} & \frac{\partial\frac{q}{p}}{\partial a_{y}} & \frac{\partial\frac{q}{p}}{\partial a_{z}} & \frac{\partial\frac{q}{p}}{\partial\frac{q}{p}}\\ \\\end{array}\right)\)

\(J_{M,p}=\left(\begin{array}{ccccccc} U_{x} & U_{y} & U_{z} & 0 & 0 & 0 & 0\\ V_{x} & V_{y} & V_{z} & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & \frac{U_{x}\left(a_{y}N_{y}+a_{z}N_{z}\right)-N_{x}\left(a_{y}U_{y}+a_{z}U_{z}\right)}{\left(a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}\right)^{2}} & \frac{U_{y}\left(a_{x}N_{x}+a_{z}N_{z}\right)-N_{y}\left(a_{x}U_{x}+a_{z}U_{z}\right)}{\left(a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}\right)^{2}} & \frac{U_{z}\left(a_{x}N_{x}+a_{y}N_{y}\right)-N_{z}\left(a_{x}U_{x}+a_{y}U_{y}\right)}{\left(a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}\right)^{2}} & 0\\ 0 & 0 & 0 & \frac{V_{x}\left(a_{y}N_{y}+a_{z}N_{z}\right)-N_{x}\left(a_{y}V_{y}+a_{z}V_{z}\right)}{\left(a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}\right)^{2}} & \frac{V_{y}\left(a_{x}N_{x}+a_{z}N_{z}\right)-N_{y}\left(a_{x}V_{x}+a_{z}V_{z}\right)}{\left(a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}\right)^{2}} & \frac{V_{z}\left(a_{x}N_{x}+a_{y}N_{y}\right)-N_{z}\left(a_{x}V_{x}+a_{y}V_{y}\right)}{\left(a_{x}N_{x}+a_{y}N_{y}+a_{z}N_{z}\right)^{2}} & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 1\\ \\\end{array}\right)\)

Implements GFAbsTrackRep.

Definition at line 442 of file RKTrackRep.cxx.

References Extrap(), fabs(), fCachePlane, fCacheSpu, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getNormal(), GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), pos, v, W, X, Y, and Z.

Referenced by getMom(), getPos(), getPosMom(), and getPosMomCov().

                                                         {
  
  TMatrixT<double> cov7x7(7,7);
  TMatrixT<double> J_pM(7,5);

  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);

  J_pM[0][3] = u.X();J_pM[0][4]=v.X(); // dx/du
  J_pM[1][3] = u.Y();J_pM[1][4]=v.Y();
  J_pM[2][3] = u.Z();J_pM[2][4]=v.Z();

  TVector3 pTilde = fSpu * (w + fState[1][0] * u + fState[2][0] * v);
  double pTildeMag = pTilde.Mag();

  //J_pM matrix is d(x,y,z,ax,ay,az,q/p) / d(q/p,u',v',u,v)

  // da_x/du'
  J_pM[3][1] = fSpu/pTildeMag*(u.X()-pTilde.X()/(pTildeMag*pTildeMag)*u*pTilde);
  J_pM[4][1] = fSpu/pTildeMag*(u.Y()-pTilde.Y()/(pTildeMag*pTildeMag)*u*pTilde);
  J_pM[5][1] = fSpu/pTildeMag*(u.Z()-pTilde.Z()/(pTildeMag*pTildeMag)*u*pTilde);
  // da_x/dv'
  J_pM[3][2] = fSpu/pTildeMag*(v.X()-pTilde.X()/(pTildeMag*pTildeMag)*v*pTilde);
  J_pM[4][2] = fSpu/pTildeMag*(v.Y()-pTilde.Y()/(pTildeMag*pTildeMag)*v*pTilde);
  J_pM[5][2] = fSpu/pTildeMag*(v.Z()-pTilde.Z()/(pTildeMag*pTildeMag)*v*pTilde);
  // dqOp/dqOp
  J_pM[6][0] = 1.;

  TMatrixT<double> J_pM_transp(J_pM);
  J_pM_transp.T();

  cov7x7 = J_pM*(fCov*J_pM_transp);

  TVector3 pos = o + fState[3][0]*u + fState[4][0]*v;
  TMatrixT<double> state7(7,1);
  state7[0][0] = pos.X();
  state7[1][0] = pos.Y();
  state7[2][0] = pos.Z();
  state7[3][0] = pTilde.X()/pTildeMag;;
  state7[4][0] = pTilde.Y()/pTildeMag;;
  state7[5][0] = pTilde.Z()/pTildeMag;;
  state7[6][0] = fState[0][0];

  double coveredDistance = this->Extrap(pl,&state7,&cov7x7);

  TVector3 O = pl.getO();
  TVector3 U = pl.getU();
  TVector3 V = pl.getV();
  TVector3 W = pl.getNormal();

  double X = state7[0][0];
  double Y = state7[1][0];
  double Z = state7[2][0];
  double AX = state7[3][0];
  double AY = state7[4][0];
  double AZ = state7[5][0];
  double QOP = state7[6][0];
  TVector3 A(AX,AY,AZ);
  TVector3 Point(X,Y,Z);
  TMatrixT<double> J_Mp(5,7);
  
  // J_Mp matrix is d(q/p,u',v',u,v) / d(x,y,z,ax,ay,az,q/p)
  J_Mp[0][6] = 1.;
  //du'/da_x
  double AtW = A*W;
  J_Mp[1][3] = (U.X()*(AtW)-W.X()*(A*U))/(AtW*AtW);
  J_Mp[1][4] = (U.Y()*(AtW)-W.Y()*(A*U))/(AtW*AtW);
  J_Mp[1][5] = (U.Z()*(AtW)-W.Z()*(A*U))/(AtW*AtW);
  //dv'/da_x
  J_Mp[2][3] = (V.X()*(AtW)-W.X()*(A*V))/(AtW*AtW);
  J_Mp[2][4] = (V.Y()*(AtW)-W.Y()*(A*V))/(AtW*AtW);
  J_Mp[2][5] = (V.Z()*(AtW)-W.Z()*(A*V))/(AtW*AtW);
  //du/dx
  J_Mp[3][0] = U.X();
  J_Mp[3][1] = U.Y();
  J_Mp[3][2] = U.Z();
  //dv/dx
  J_Mp[4][0] = V.X();
  J_Mp[4][1] = V.Y();
  J_Mp[4][2] = V.Z();
  
  TMatrixT<double> J_Mp_transp(J_Mp);
  J_Mp_transp.T();

  covPred.ResizeTo(5,5);

  covPred = J_Mp*(cov7x7*J_Mp_transp);

  statePred.ResizeTo(5,1);
  statePred[0][0] = QOP;
  statePred[1][0] = (A*U)/(A*W);
  statePred[2][0] = (A*V)/(A*W);
  statePred[3][0] = (Point-O)*U;
  statePred[4][0] = (Point-O)*V;
  
  fCachePlane = pl;
  fCacheSpu = (A*W)/fabs(A*W);

  return coveredDistance;
}

double RKTrackRep::extrapolate ( const GFDetPlane &  pl, TMatrixT< double > &  statePred  )

virtual

returns the tracklength spanned in this extrapolation

Reimplemented from GFAbsTrackRep.

Definition at line 550 of file RKTrackRep.cxx.

References Extrap(), GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getNormal(), GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), pos, v, W, X, Y, and Z.

                                                           {

  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);


  TVector3 pTilde = fSpu* (w + fState[1][0] * u + fState[2][0] * v);
  double pTildeMag = pTilde.Mag();

  TVector3 pos = o + fState[3][0]*u + fState[4][0]*v;

  TMatrixT<double> state7(7,1);
  state7[0][0] = pos.X();
  state7[1][0] = pos.Y();
  state7[2][0] = pos.Z();
  state7[3][0] = pTilde.X()/pTildeMag;
  state7[4][0] = pTilde.Y()/pTildeMag;
  state7[5][0] = pTilde.Z()/pTildeMag;
  state7[6][0] = fState[0][0];

  TVector3 O = pl.getO();
  TVector3 U = pl.getU();
  TVector3 V = pl.getV();
  TVector3 W = pl.getNormal();

  double coveredDistance = this->Extrap(pl,&state7);

  double X = state7[0][0];
  double Y = state7[1][0];
  double Z = state7[2][0];
  double AX = state7[3][0];
  double AY = state7[4][0];
  double AZ = state7[5][0];
  double QOP = state7[6][0];
  TVector3 A(AX,AY,AZ);
  TVector3 Point(X,Y,Z);

  statePred.ResizeTo(5,1);
  statePred[0][0] = QOP;
  statePred[1][0] = (A*U)/(A*W);
  statePred[2][0] = (A*V)/(A*W);
  statePred[3][0] = (Point-O)*U;
  statePred[4][0] = (Point-O)*V;

  return coveredDistance;
}

double GFAbsTrackRep::extrapolate ( const GFDetPlane &  plane )

inherited

This changes the state and cov and plane of the rep.

This method extrapolates to to the plane and sets the results of state, cov and also plane in itself.

Definition at line 33 of file GFAbsTrackRep.cxx.

References GFAbsTrackRep::extrapolate(), GFAbsTrackRep::fDimension, and GFAbsTrackRep::setData().

                                                        {
  TMatrixT<double> statePred(fDimension,1);
  TMatrixT<double> covPred(fDimension,fDimension);
  double retVal = extrapolate(plane,statePred,covPred);
  setData(statePred,plane,&covPred);
  return retVal;
}

void RKTrackRep::extrapolateToLine ( const TVector3 &  point1, const TVector3 &  point2, TVector3 &  poca, TVector3 &  dirInPoca, TVector3 &  poca_onwire  )

virtual

This method extrapolates to the point of closest approach to a line.

Reimplemented from GFAbsTrackRep.

Definition at line 390 of file RKTrackRep.cxx.

References Extrap(), fabs(), GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), MINSTEP, poca2Line(), point, GFDetPlane::setO(), GFDetPlane::setU(), GFDetPlane::setV(), and v.

                                                         {
  static const int maxIt(30);

  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);

  TVector3 pTilde = fSpu* (w + fState[1][0] * u + fState[2][0] * v);
  pTilde.SetMag(1.);

  TVector3 point = o + fState[3][0]*u + fState[4][0]*v;

  TMatrixT<double> state7(7,1);
  state7[0][0] = point.X();
  state7[1][0] = point.Y();
  state7[2][0] = point.Z();
  state7[3][0] = pTilde.X();
  state7[4][0] = pTilde.Y();
  state7[5][0] = pTilde.Z();
  state7[6][0] = fState[0][0];

  double coveredDistance(0.);

  GFDetPlane pl;
  int iterations(0);

  while(true){
    pl.setO(point1);
    TVector3 currentDir(state7[3][0],state7[4][0],state7[5][0]);
    pl.setU(currentDir.Cross(point2-point1));
    pl.setV(point2-point1);
    coveredDistance = this->Extrap(pl,&state7);

    if(fabs(coveredDistance)<MINSTEP) break;
    if(++iterations == maxIt) {
      GFException exc("RKTrackRep::extrapolateToLine ==> extrapolation to line failed, maximum number of iterations reached",__LINE__,__FILE__);
      throw exc;
    }
  }
  poca.SetXYZ(state7[0][0],state7[1][0],state7[2][0]);
  dirInPoca.SetXYZ(state7[3][0],state7[4][0],state7[5][0]);
  poca_onwire = poca2Line(point1,point2,poca);
}

void RKTrackRep::extrapolateToPoint ( const TVector3 &  pos, TVector3 &  poca, TVector3 &  dirInPoca  )

virtual

This method is to extrapolate the track to point of closest approach to a point in space.

Reimplemented from GFAbsTrackRep.

Definition at line 329 of file RKTrackRep.cxx.

References Extrap(), fabs(), GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), MINSTEP, point, GFDetPlane::setON(), and v.

Referenced by PndLmdBPRungeKuttaTask::Exec(), and PndLmdPerformanceTask::Exec().

                                                       {

  static const int maxIt(30);

  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);

  TVector3 pTilde = fSpu* (w + fState[1][0] * u + fState[2][0] * v);
  pTilde.SetMag(1.);

  TVector3 point = o + fState[3][0]*u + fState[4][0]*v;

  TMatrixT<double> state7(7,1);
  state7[0][0] = point.X();
  state7[1][0] = point.Y();
  state7[2][0] = point.Z();
  state7[3][0] = pTilde.X();
  state7[4][0] = pTilde.Y();
  state7[5][0] = pTilde.Z();
  state7[6][0] = fState[0][0];

  double coveredDistance(0.);

  GFDetPlane pl;
  int iterations(0);

  while(true){
    pl.setON(pos,TVector3(state7[3][0],state7[4][0],state7[5][0]));
    coveredDistance =  this->Extrap(pl,&state7);

    if(fabs(coveredDistance)<MINSTEP) break;
    if(++iterations == maxIt) {
      GFException exc("RKTrackRep::extrapolateToPoint ==> extrapolation to point failed, maximum number of iterations reached",__LINE__,__FILE__);
      throw exc;
    }
  }
  poca.SetXYZ(state7[0][0],state7[1][0],state7[2][0]);
  dirInPoca.SetXYZ(state7[3][0],state7[4][0],state7[5][0]);
}

const TMatrixT< double > * RKTrackRep::getAuxInfo ( const GFDetPlane &  )

virtual

Get auxillary information from the track representation.

AuxInfo is a mechanism which allows creators of track repersentations to hand out any information they like (as long as it is compatible with a TMatrixT<double>). It should be used if setData requires additional information to update the representation, but it can also be used for debugging information if needed. See also the documentation of GFAbsTrackRep::setData().

Reimplemented from GFAbsTrackRep.

Definition at line 57 of file RKTrackRep.cxx.

References fAuxInfo, fCachePlane, and fCacheSpu.

                                                                   {

  if(pl!=fCachePlane) {
    std::cerr << "RKTrackRep::getAuxInfo() - Fatal error: Trying to get auxillary information with planes mismatch (Information returned does not belong to requested plane)! -> abort in line " << __LINE__ << std::endl;
        throw;
  }
  fAuxInfo.ResizeTo(1,1);
  fAuxInfo(0,0) = fCacheSpu;
  return &fAuxInfo;

}

double RKTrackRep::getCharge ( ) const

inlinevirtual

Returns charge.

Implements GFAbsTrackRep.

Definition at line 144 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

References fCharge.

{return fCharge;}

double GFAbsTrackRep::getChiSqu ( ) const

inlineinherited

Definition at line 244 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fChiSqu.

Referenced by GFTrack::getChiSqu(), and GFAbsTrackRep::getRedChiSqu().

                                  {
    return fChiSqu;
  }

TMatrixT<double> GFAbsTrackRep::getCov ( ) const

inlineinherited

Definition at line 198 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fCov.

Referenced by GFTrack::blowUpCovs(), GFKalman::processHit(), and GFKalman::processTrack().

                                         {
    return fCov;
  }

double GFAbsTrackRep::getCovElem ( int  i, int  j  ) const

inlineinherited

Definition at line 203 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fCov.

{return fCov(i,j);}

unsigned int GFAbsTrackRep::getDim ( ) const

inlineinherited

returns dimension of state vector

Definition at line 191 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fDimension.

Referenced by GeaneTrackRep::extrapolateToPoint(), GFKalman::getChi2Hit(), GFAbsTrackRep::getNDF(), GFTrack::getResiduals(), and GFKalman::processHit().

{return fDimension;}  

TMatrixT<double> GFAbsTrackRep::getFirstCov ( ) const

inlineinherited

Definition at line 229 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fFirstCov.

Referenced by GenfitTrack2PndTrack().

                                              {
    return fFirstCov;
  }

GFDetPlane GFAbsTrackRep::getFirstPlane ( ) const

inlineinherited

Definition at line 232 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fFirstPlane.

Referenced by GenfitTrack2PndTrack().

                                          {
    return fFirstPlane;
  }

TMatrixT<double> GFAbsTrackRep::getFirstState ( ) const

inlineinherited

Definition at line 226 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fFirstState.

Referenced by GenfitTrack2PndTrack().

                                                {
    return fFirstState;
  }

TMatrixT<double> GFAbsTrackRep::getLastCov ( ) const

inlineinherited

Definition at line 238 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fLastCov.

Referenced by GenfitTrack2PndTrack().

                                             {
    return fLastCov;
  }

GFDetPlane GFAbsTrackRep::getLastPlane ( ) const

inlineinherited

Definition at line 241 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fLastPlane.

Referenced by GenfitTrack2PndTrack().

                                         {
    return fLastPlane;
  }

TMatrixT<double> GFAbsTrackRep::getLastState ( ) const

inlineinherited

Definition at line 235 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fLastState.

Referenced by GenfitTrack2PndTrack().

                                               {
    return fLastState;
  }

TVector3 RKTrackRep::getMom ( const GFDetPlane &  pl )

virtual

Returns momentum of the track in the plane.

If GFDetPlane equals the reference plane fRefPlane, returns current momentum; otherwise it extrapolates the track to the plane and returns the momentum.

Implements GFAbsTrackRep.

Definition at line 297 of file RKTrackRep.cxx.

References extrapolate(), fabs(), fCacheSpu, GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getNormal(), GFDetPlane::getU(), and GFDetPlane::getV().

                                               {
  TMatrixT<double> statePred(fState);
  TVector3 retmom;
  if(pl!=fRefPlane) {
    extrapolate(pl,statePred);
    retmom = fCacheSpu*(pl.getNormal()+statePred[1][0]*pl.getU()+statePred[2][0]*pl.getV());
  }
  else{
    retmom = fSpu*(pl.getNormal()+statePred[1][0]*pl.getU()+statePred[2][0]*pl.getV());
  }
  retmom.SetMag(1./fabs(statePred[0][0]));
  return retmom;
}

TVector3 GFAbsTrackRep::getMom ( )

inlineinherited

Definition at line 221 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fRefPlane, and GFAbsTrackRep::getMom().

Referenced by GeaneTrackRep::extrapolate(), GeaneTrackRep::extrapolateToLine(), GeaneTrackRep::extrapolateToPoint(), and GFAbsTrackRep::getMom().

{return getMom(fRefPlane);}

unsigned int GFAbsTrackRep::getNDF ( ) const

inlineinherited

Definition at line 252 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fNdf, and GFAbsTrackRep::getDim().

Referenced by GFTrack::getNDF(), and GFAbsTrackRep::getRedChiSqu().

                                     {
    if(fNdf>getDim())  return fNdf-getDim();
    return 0;
  }

int RKTrackRep::getPDG ( )

inline

Definition at line 146 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

References fPdg.

{return fPdg;};

TVector3 RKTrackRep::getPos ( const GFDetPlane &  pl )

virtual

Returns position of the track in the plane.

If GFDetPlane equals the reference plane fRefPlane, returns current position; otherwise it extrapolates the track to the plane and returns the position.

Implements GFAbsTrackRep.

Definition at line 287 of file RKTrackRep.cxx.

References extrapolate(), GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), and s.

                                               {
  if(pl!=fRefPlane){
    TMatrixT<double> s(5,1);
    extrapolate(pl,s);
    return pl.getO()+s[3][0]*pl.getU()+s[4][0]*pl.getV();
  }
  return fRefPlane.getO()+fState[3][0]*fRefPlane.getU()+fState[4][0]*fRefPlane.getV();
}

TVector3 GFAbsTrackRep::getPos ( )

inlineinherited

Definition at line 220 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fRefPlane, and GFAbsTrackRep::getPos().

Referenced by GeaneTrackRep::extrapolateToLine(), and GFAbsTrackRep::getPos().

{return getPos(fRefPlane);}

void RKTrackRep::getPosMom ( const GFDetPlane &  pl, TVector3 &  pos, TVector3 &  mom  )

virtual

Gets position and momentum in the plane.

If GFDetPlane equals the reference plane fRefPlane, it gets current position and momentum; otherwise it extrapolates the track to the plane and gets the position and momentum.

Implements GFAbsTrackRep.

Definition at line 312 of file RKTrackRep.cxx.

References extrapolate(), fabs(), fCacheSpu, GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getNormal(), GFDetPlane::getO(), GFDetPlane::getU(), and GFDetPlane::getV().

                                         {
  TMatrixT<double> statePred(fState);
  if(pl!=fRefPlane) {
    extrapolate(pl,statePred);
    mom = fCacheSpu*(pl.getNormal()+statePred[1][0]*pl.getU()+statePred[2][0]*pl.getV());
  }
  else{
    mom = fSpu*(pl.getNormal()+statePred[1][0]*pl.getU()+statePred[2][0]*pl.getV());
  }
  mom.SetMag(1./fabs(statePred[0][0]));
  pos = pl.getO()+(statePred[3][0]*pl.getU())+(statePred[4][0]*pl.getV());
}

void RKTrackRep::getPosMomCov ( const GFDetPlane &  pl, TVector3 &  pos, TVector3 &  mom, TMatrixT< double > &  cov  )

virtual

method which gets position, momentum and 6x6 covariance matrix

default implementation in cxx file, if a ConcreteTrackRep can not implement this functionality

Reimplemented from GFAbsTrackRep.

Definition at line 1148 of file RKTrackRep.cxx.

References extrapolate(), fCacheSpu, fCharge, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), p, and W.

Referenced by PndLmdBPRungeKuttaTask::Exec().

                                                                                                      {

  const TVector3 U=pl.getU();
  const TVector3 V=pl.getV();
  const TVector3 W=U.Cross(V);

  TMatrixT<double> statePred=fState;
  TMatrixT<double> covPred=fCov;
  double spu=fSpu;
  if(pl!=fRefPlane)
  {
    extrapolate(pl, statePred, covPred);
    spu=fCacheSpu;
  }

  const double p=fCharge/statePred[0][0]; //Magnitude of the momentum.
  const TVector3 pTilde=spu*(W+statePred[1][0]*U+statePred[2][0]*V);
  const double pTildeMagnitude=pTilde.Mag();

  TMatrixT<double> jacobian(6, 5); //Jacobian matrix \frac{\partial\left(x, y, z, p_x, p_y, p_z\right)}{\partial\left(\frac{q}{p}, u^\prime, v^\prime, u, v\right)}
  jacobian[0][3]=U.X();
  jacobian[0][4]=V.X();
  jacobian[1][3]=U.Y();
  jacobian[1][4]=V.Y();
  jacobian[2][3]=U.Z();
  jacobian[2][4]=V.Z();
  jacobian[3][1]=p*spu/pTildeMagnitude*(U.X()-pTilde.X()*(U*pTilde)/(pTildeMagnitude*pTildeMagnitude));
  jacobian[3][2]=p*spu/pTildeMagnitude*(V.X()-pTilde.X()*(V*pTilde)/(pTildeMagnitude*pTildeMagnitude));
  jacobian[4][1]=p*spu/pTildeMagnitude*(U.Y()-pTilde.Y()*(U*pTilde)/(pTildeMagnitude*pTildeMagnitude));
  jacobian[4][2]=p*spu/pTildeMagnitude*(V.Y()-pTilde.Y()*(V*pTilde)/(pTildeMagnitude*pTildeMagnitude));
  jacobian[5][1]=p*spu/pTildeMagnitude*(U.Z()-pTilde.Z()*(U*pTilde)/(pTildeMagnitude*pTildeMagnitude));
  jacobian[5][2]=p*spu/pTildeMagnitude*(V.Z()-pTilde.Z()*(V*pTilde)/(pTildeMagnitude*pTildeMagnitude));

  TMatrixT<double> transposedJacobian=jacobian;
  transposedJacobian.T();

  cov.ResizeTo(6, 6);

  pos=pl.getO()+statePred[3][0]*U+statePred[4][0]*V;
  mom=p/pTildeMagnitude*pTilde;
  cov=jacobian*covPred*transposedJacobian;
}

void GFAbsTrackRep::getPosMomCov ( TVector3 &  pos, TVector3 &  mom, TMatrixT< double > &  c  )

inlineinherited

Definition at line 222 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fRefPlane, and GFAbsTrackRep::getPosMomCov().

                                                                    {
    getPosMomCov(fRefPlane,pos,mom,c);
  }

double GFAbsTrackRep::getRedChiSqu ( ) const

inlineinherited

returns chi2/ndf

Definition at line 248 of file GFAbsTrackRep.h.

References GFAbsTrackRep::getChiSqu(), and GFAbsTrackRep::getNDF().

Referenced by GFTrack::getRedChiSqu().

                                     {
    if(getNDF()>0) return getChiSqu()/getNDF();
    return 0;
  }

const GFDetPlane& GFAbsTrackRep::getReferencePlane ( ) const

inlineinherited

Definition at line 295 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fRefPlane.

Referenced by GFKalman::processHit(), and GFKalman::processTrack().

{return fRefPlane;}

TMatrixT<double> GFAbsTrackRep::getState ( ) const

inlineinherited

Definition at line 195 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fState.

Referenced by GFTrack::fillGeoTrack(), GFTrack::getResiduals(), GFKalman::processHit(), and GFKalman::processTrack().

                                           {
    return fState;
  }

double GFAbsTrackRep::getStateElem ( int  i ) const

inlineinherited

Definition at line 202 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fState.

{return fState(i,0);}

bool GFAbsTrackRep::getStatusFlag ( )

inlineinherited

Definition at line 318 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fStatusFlag.

Referenced by GFTrack::blowUpCovs(), PndHypMicroWriter::Exec(), PndHypMicroIdealWriter::Exec(), PndHypDKalmanTask::Exec(), GFKalman::fittingPass(), for(), and GFDaf::processTrack().

                              {
    return fStatusFlag;
  }

bool RKTrackRep::hasAuxInfo ( )

inlinevirtual

See if the track representation has auxillary information stored.

See if auxillary information is stored in the track representation. See the documentation of GFAbsTrackRep::getAuxInfo() for details.

Reimplemented from GFAbsTrackRep.

Definition at line 162 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

{ return true; }

RKTrackRep& RKTrackRep::operator= ( const RKTrackRep *  )

inlineprivate

Definition at line 168 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

{return *this;}; // rhs // [R.K.03/2017] unused variable(s)

TVector3 RKTrackRep::poca2Line ( const TVector3 &  extr1, const TVector3 &  extr2, const TVector3 &  point  ) const

private

Definition at line 376 of file RKTrackRep.cxx.

References t.

Referenced by extrapolateToLine().

                                                                                                      {
  
  TVector3 theWire = extr2-extr1;
  if(theWire.Mag()<1.E-8){
    GFException exc("RKTrackRep::poca2Line ==> try to find poca between line and point, but the line is really just a point",__LINE__,__FILE__);
    throw exc;
  }
  double t = 1./(theWire*theWire)*(point*theWire+extr1*extr1-extr1*extr2);
  return (extr1+t*theWire);
}

void GFAbsTrackRep::Print ( ) const

virtualinherited

Definition at line 97 of file GFAbsTrackRep.cxx.

References GFAbsTrackRep::fChiSqu, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, and GFDetPlane::Print().

Referenced by PndLmdBPRungeKuttaTask::Exec(), PndHypDKalmanTask::Exec(), and GFTrack::Print().

                           {
  std::cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
  std::cout<<"GFAbsTrackRep::Parameters at reference plane ";
  fRefPlane.Print();
  std::cout<<"GFAbsTrackRep::State"<<std::endl;
  fState.Print();
  std::cout<<"GFAbsTrackRep::Covariances"<<std::endl;
  fCov.Print();
  std::cout<<"GFAbsTrackRep::chi^2"<<std::endl;
  std::cout<<fChiSqu<<std::endl;
  std::cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << std::endl;
}

virtual GFAbsTrackRep* RKTrackRep::prototype ( ) const

inlinevirtual

Implements GFAbsTrackRep.

Definition at line 75 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

References RKTrackRep().

{return new RKTrackRep();}

void GFAbsTrackRep::reset ( )

virtualinherited

Definition at line 84 of file GFAbsTrackRep.cxx.

References GFAbsTrackRep::fCov, GFAbsTrackRep::fFirstCov, GFAbsTrackRep::fFirstState, GFAbsTrackRep::fLastCov, GFAbsTrackRep::fLastState, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, and GFDetPlane::set().

                    {
  std::cout<<"GFAbsTrackRep::reset"<<std::endl;
  TVector3 nullVec(0.,0.,0.);
  fRefPlane.set(nullVec,nullVec,nullVec);
  fState.Zero();
  fCov.Zero();
  fFirstState.Zero();
  fFirstCov.Zero();
  fLastState.Zero();
  fLastCov.Zero();
}

bool RKTrackRep::RKutta ( const GFDetPlane &  plane, double *  P, double &  coveredDistance, std::vector< TVector3 > &  points, std::vector< double > &  pointLengths, const double &  maxLen = -1, bool  calcCov = true  ) const

private

Propagates the particle through the magnetic field.

If the propagation is successfull and the plane is reached, the function returns true. The argument P has to contain the state (P[0] - P[6]) and a unity matrix (P[7] - P[55]) with the last column multiplied wit q/p (hence P[55] is not 1 but q/p). Propagated state and the jacobian (with the last column multiplied wit q/p) of the extrapolation are written to P. In the main loop of the Runge Kutta algorithm, the steppers in #fEffect are called and may reduce the estimated stepsize so that a maximum momentum loss will not be exceeded. If this is the case, RKutta() will only propagate the reduced distance and then return. This is to ensure that material effects, which are calculated after the propagation, are taken into account properly.

Definition at line 640 of file RKTrackRep.cxx.

References GFDetPlane::distance(), error(), fabs(), fCharge, fPdg, GFFieldManager::getFieldVal(), GFMaterialEffects::getInstance(), GFDetPlane::getNormal(), GFDetPlane::getO(), i, GFDetPlane::inActive(), MINSTEP, pos, r, R, sqrt(), GFMaterialEffects::stepper(), and W.

Referenced by Extrap().

                                             {

  static const double EC     = .000149896229;   // c/(2*10^12) resp. c/2Tera
  static const double DLT    = .0002;           // max. deviation for approximation-quality test
  static const double DLT32  = DLT/32.;         //
  static const double P3     = 1./3.;           // 1/3
  static const double Smax   = 100.;            // max. step allowed > 0 
  static const double Wmax   = 3000.;           // max. way allowed
  static const double Pmin   = 4.E-3;           // minimum momentum for propagation [GeV]
  static const int    ND     = 56;              // number of variables for derivatives calculation
  static const int    ND1    = ND-7;            // = 49
  double* R           = &P[0];                  // Start coordinates  in cm     ( x,  y,  z)
  double* A           = &P[3];                  // Start directions             (ax, ay, az);   ax^2+ay^2+az^2=1
  double  SA[3]       = {0.,0.,0.};             // Start directions derivatives 
  double  Pinv        = P[6]*EC;                // P[6] is charge/momentum in e/(Gev/c)
  double  Way         = 0.;                     // Total way of the trajectory
  double  Way2        = 0.;                     // Total way of the trajectory with correct signs
  bool    error       = false;                  // Error of propogation
  bool    stopBecauseOfMaterial = false;        // does not go through main loop again when stepsize is reduced by stepper

  points.clear();
  pointPaths.clear();
  //std::cout<<"coords  "<<R[0]<<"  "<<R[1]<<"   "<<R[2]<<  std::endl;
  //std::cout<<"R       "<<sqrt(pow(R[0],2)+pow(R[1],2))<<  std::endl;  
  //std::cout<<"momentum "<<fabs(fCharge/P[6])<< std::endl;
  if(fabs(fCharge/P[6])<Pmin){
    std::cerr << "RKTrackRep::RKutta ==> momentum too low: " << fabs(fCharge/P[6])*1000. << " MeV" << std::endl;
    return (false);
  }
  
  double SU[4];
  TVector3 O = plane.getO();
  TVector3 W = plane.getNormal(); 
  if(W*O > 0){          // make SU vector point away from origin
    SU[0] = W.X();
    SU[1] = W.Y();
    SU[2] = W.Z();
  }
  else{
    SU[0] = -1.*W.X();
    SU[1] = -1.*W.Y();
    SU[2] = -1.*W.Z();
  }
  SU[3] = plane.distance(0.,0.,0.);

  //
  // Step estimation until surface
  //
  double Step,An,Dist,Dis,S,Sl=0;

  points.push_back(TVector3(R[0],R[1],R[2]));
  pointPaths.push_back(0.);

  An=A[0]*SU[0]+A[1]*SU[1]+A[2]*SU[2];          // An = A * N;  component of A normal to surface
  if(fabs(An) < 1.E-6) {
    std::cerr << "RKTrackRep::RKutta ==> cannot propagate perpendicular to plane " << std::endl;
    return false;                               // no propagation if A perpendicular to surface
  }
  if( plane.inActive(TVector3(R[0],R[1],R[2]),TVector3(A[0],A[1],A[2]))) {  // if direction is not pointing to active part of surface
    Dist=SU[3]-R[0]*SU[0]-R[1]*SU[1]-R[2]*SU[2];                                // Distance between start coordinates and surface
    Step=Dist/An;
  }
  else{                                                                                   // make sure to extrapolate towards surface
    if( (O.X()-R[0])*A[0] + (O.Y()-R[1])*A[1] + (O.Z()-R[2])*A[2] >0 ){         // if direction A pointing from start coordinates R towards surface
      Dist = sqrt((R[0]-O.X())*(R[0]-O.X())+                                     // |R-O|; Distance between start coordinates and origin of surface
                  (R[1]-O.Y())*(R[1]-O.Y())+
                  (R[2]-O.Z())*(R[2]-O.Z()));      
    }
    else{                                                                                       // if direction pointing away from surface
      Dist = -1.*sqrt((R[0]-O.X())*(R[0]-O.X())+
                      (R[1]-O.Y())*(R[1]-O.Y())+
                      (R[2]-O.Z())*(R[2]-O.Z()));            
    }
    Step=Dist;    
  }

  if(fabs(Step)>Wmax) {
    std::cerr<<"RKTrackRep::RKutta ==> Too long extrapolation requested : "<<Step<<" cm !"<<std::endl;
    std::cerr<<"X = "<<R[0]<<" Y = "<<R[1]<<" Z = "<<R[2]
             <<"  COSx = "<<A[0]<<"  COSy = "<<A[1]<<"  COSz = "<<A[2]<<std::endl;
    std::cout<<"Destination  X = "<<SU[0]*SU[3]<<std::endl;
    return(false);
  }

  // reduce maximum stepsize S to Smax
  Step>Smax ? S=Smax : Step<-Smax ? S=-Smax : S=Step;   
  
  //
  // Main cycle of Runge-Kutta method
  //

  //for saving points only when the direction didnt change
  int Ssign=1;
  if(S<0) Ssign = -1;

  while(fabs(Step)>MINSTEP && !stopBecauseOfMaterial) {
    
    // call stepper and reduce stepsize
    double stepperLen;
    stepperLen = GFMaterialEffects::getInstance()->stepper(fabs(S),
                                  R[0],R[1],R[2],
                                  Ssign*A[0],Ssign*A[1],Ssign*A[2],
                                  fabs(fCharge/P[6]),
                                  fPdg);
    if (stepperLen<MINSTEP) stepperLen=MINSTEP; // prevents tiny stepsizes that can slow down the program
    if (S > stepperLen) {
      S = stepperLen;
      stopBecauseOfMaterial = true;
    }
    else if (S < -stepperLen) {
      S = -stepperLen;  
      stopBecauseOfMaterial = true;
    }

    double H0[12],H1[12],H2[12],r[3];
    double S3=P3*S, S4=.25*S, PS2=Pinv*S; 
    
    //
    // First point
    //   
    r[0]=R[0]      ; r[1]=R[1]      ; r[2]=R[2]      ;  
    TVector3 pos(r[0],r[1],r[2]);                                               // vector of start coordinates R0       (x, y, z)
    TVector3 H0vect = GFFieldManager::getFieldVal(pos);                         // magnetic field in 10^-4 T = kGauss
    H0[0]=PS2*H0vect.X(); H0[1]=PS2*H0vect.Y(); H0[2]=PS2*H0vect.Z();           // H0 is PS2*(Hx, Hy, Hz) @ R0
    double A0=A[1]*H0[2]-A[2]*H0[1], B0=A[2]*H0[0]-A[0]*H0[2], C0=A[0]*H0[1]-A[1]*H0[0]; // (ax, ay, az) x H0
    double A2=A[0]+A0              , B2=A[1]+B0              , C2=A[2]+C0              ; // (A0, B0, C0) + (ax, ay, az)
    double A1=A2+A[0]              , B1=B2+A[1]              , C1=C2+A[2]              ; // (A0, B0, C0) + 2*(ax, ay, az)
      
    //
    // Second point
    //
    r[0]+=A1*S4    ; r[1]+=B1*S4    ; r[2]+=C1*S4    ;   //setup.Field(r,H1);
    pos.SetXYZ(r[0],r[1],r[2]);
    TVector3 H1vect = GFFieldManager::getFieldVal(pos);
    H1[0]=H1vect.X()*PS2; H1[1]=H1vect.Y()*PS2;H1[2]=H1vect.Z()*PS2;    // H1 is PS2*(Hx, Hy, Hz) @ (x, y, z) + 0.25*S * [(A0, B0, C0) + 2*(ax, ay, az)]
    double A3,B3,C3,A4,B4,C4,A5,B5,C5;
    A3 = B2*H1[2]-C2*H1[1]+A[0]; B3=C2*H1[0]-A2*H1[2]+A[1]; C3=A2*H1[1]-B2*H1[0]+A[2]; // (A2, B2, C2) x H1 + (ax, ay, az)
    A4 = B3*H1[2]-C3*H1[1]+A[0]; B4=C3*H1[0]-A3*H1[2]+A[1]; C4=A3*H1[1]-B3*H1[0]+A[2]; // (A3, B3, C3) x H1 + (ax, ay, az)
    A5 = A4-A[0]+A4            ; B5=B4-A[1]+B4            ; C5=C4-A[2]+C4            ; //    2*(A4, B4, C4) - (ax, ay, az)

    //
    // Last point
    //
    r[0]=R[0]+S*A4 ; r[1]=R[1]+S*B4 ; r[2]=R[2]+S*C4 ;  //setup.Field(r,H2);
    pos.SetXYZ(r[0],r[1],r[2]);
    TVector3 H2vect = GFFieldManager::getFieldVal(pos);
    H2[0]=H2vect.X()*PS2; H2[1]=H2vect.Y()*PS2;H2[2]=H2vect.Z()*PS2;    // H2 is PS2*(Hx, Hy, Hz) @ (x, y, z) + 0.25*S * (A4, B4, C4)
    double A6=B5*H2[2]-C5*H2[1], B6=C5*H2[0]-A5*H2[2], C6=A5*H2[1]-B5*H2[0]; // (A5, B5, C5) x H2

    //
    // Test approximation quality on given step and possible step reduction
    //
    double EST = fabs((A1+A6)-(A3+A4))+fabs((B1+B6)-(B3+B4))+fabs((C1+C6)-(C3+C4));  // EST = ||(ABC1+ABC6)-(ABC3+ABC4)||_1  =  ||(axzy x H0 + ABC5 x H2) - (ABC2 x H1 + ABC3 x H1)||_1
    if(EST>DLT) {
      S*=0.5; 
      stopBecauseOfMaterial = false;
      continue;
    }
    
    //
    // Derivatives of track parameters in last point
    //
    if(calcCov){
      for(int i=7; i!=ND; i+=7) {                               // i = 7, 14, 21, 28, 35, 42, 49;    ND = 56;   ND1 = 49; rows of Jacobian
        
        double* dR = &P[i];                                             // dR = (dX/dpN,  dY/dpN,  dZ/dpN)
        double* dA = &P[i+3];                                           // dA = (dAx/dpN, dAy/dpN, dAz/dpN); N = X,Y,Z,Ax,Ay,Az,q/p
        
        //first point
        double dA0   = H0[ 2]*dA[1]-H0[ 1]*dA[2];               // dA0/dp       }
        double dB0   = H0[ 0]*dA[2]-H0[ 2]*dA[0];               // dB0/dp        } = dA x H0    
        double dC0   = H0[ 1]*dA[0]-H0[ 0]*dA[1];               // dC0/dp       }
        
        if(i==ND1) {dA0+=A0; dB0+=B0; dC0+=C0;}                 // if last row: (dA0, dB0, dC0) := (dA0, dB0, dC0) + (A0, B0, C0)
        
        double dA2   = dA0+dA[0];                               // }
        double dB2   = dB0+dA[1];                       //  } = (dA0, dB0, dC0) + dA
        double dC2   = dC0+dA[2];                               // }
         
        //second point
        double dA3   = dA[0]+dB2*H1[2]-dC2*H1[1];               // dA3/dp       }
        double dB3   = dA[1]+dC2*H1[0]-dA2*H1[2];               // dB3/dp        } = dA + (dA2, dB2, dC2) x H1  
        double dC3   = dA[2]+dA2*H1[1]-dB2*H1[0];               // dC3/dp       }
        
        if(i==ND1) {dA3+=A3-A[0]; dB3+=B3-A[1]; dC3+=C3-A[2];} // if last row: (dA3, dB3, dC3) := (dA3, dB3, dC3) + (A3, B3, C3) - (ax, ay, az)

        double dA4   = dA[0]+dB3*H1[2]-dC3*H1[1];               // dA4/dp       }
        double dB4   = dA[1]+dC3*H1[0]-dA3*H1[2];               // dB4/dp        } = dA + (dA3, dB3, dC3) x H1  
        double dC4   = dA[2]+dA3*H1[1]-dB3*H1[0];               // dC4/dp       }
        
        if(i==ND1) {dA4+=A4-A[0]; dB4+=B4-A[1]; dC4+=C4-A[2];} // if last row: (dA4, dB4, dC4) := (dA4, dB4, dC4) + (A4, B4, C4) - (ax, ay, az)
        
        //last point    
        double dA5   = dA4+dA4-dA[0];                           // }
        double dB5   = dB4+dB4-dA[1];                           //  } =  2*(dA4, dB4, dC4) - dA
        double dC5   = dC4+dC4-dA[2];                   // }

        double dA6   = dB5*H2[2]-dC5*H2[1];                     // dA6/dp       }
        double dB6   = dC5*H2[0]-dA5*H2[2];                     // dB6/dp        } = (dA5, dB5, dC5) x H2       
        double dC6   = dA5*H2[1]-dB5*H2[0];                     // dC6/dp       }       

        if(i==ND1) {dA6+=A6; dB6+=B6; dC6+=C6;}                 // if last row: (dA6, dB6, dC6) := (dA6, dB6, dC6) + (A6, B6, C6)                                    
        
        dR[0]+=(dA2+dA3+dA4)*S3; dA[0] = (dA0+dA3+dA3+dA5+dA6)*P3;      // dR := dR + S3*[(dA2, dB2, dC2) +   (dA3, dB3, dC3) + (dA4, dB4, dC4)]      
        dR[1]+=(dB2+dB3+dB4)*S3; dA[1] = (dB0+dB3+dB3+dB5+dB6)*P3;      // dA :=     1/3*[(dA0, dB0, dC0) + 2*(dA3, dB3, dC3) + (dA5, dB5, dC5) + (dA6, dB6, dC6)]
        dR[2]+=(dC2+dC3+dC4)*S3; dA[2] = (dC0+dC3+dC3+dC5+dC6)*P3;
      }
    }
    
    Way2 += S;                          // add stepsize to way (signed)
    if((Way+=fabs(S))>Wmax){ 
      std::cerr<<"RKTrackRep::RKutta ==> Trajectory is longer than length limit : "<<Way<<" cm !"
      << " p/q = "<<1./P[6]<< " GeV"<<std::endl;
      return(false);
    }
    
    //
    // Track parameters in last point
    //   
    R[0]+=(A2+A3+A4)*S3; A[0]+=(SA[0]=(A0+A3+A3+A5+A6)*P3-A[0]);  // R  = R0 + S3*[(A2, B2, C2) +   (A3, B3, C3) + (A4, B4, C4)] 
    R[1]+=(B2+B3+B4)*S3; A[1]+=(SA[1]=(B0+B3+B3+B5+B6)*P3-A[1]);  // A  =     1/3*[(A0, B0, C0) + 2*(A3, B3, C3) + (A5, B5, C5) + (A6, B6, C6)]
    R[2]+=(C2+C3+C4)*S3; A[2]+=(SA[2]=(C0+C3+C3+C5+C6)*P3-A[2]);        // SA = A_new - A_old
    Sl=S;       // last S used
    
    // if extrapolation has changed direction, delete the last point, because it is
    // not a consecutive point to be used for material estimations
    if(Ssign*S<0.) {
      pointPaths.at(pointPaths.size()-1)+=S;
      points.erase(points.end());
    }
    else{
      pointPaths.push_back(S);
    }

    points.push_back(TVector3(R[0],R[1],R[2]));

    double CBA = 1./sqrt(A[0]*A[0]+A[1]*A[1]+A[2]*A[2]);        // 1/|A|
    A[0]*=CBA; A[1]*=CBA; A[2]*=CBA;                            // normalize A
  
    // Step estimation until surface and test conditions for stop of propogation
    if(fabs(Way2)>Wmax) {
      Dis=0.;
      Dist=0.;
      S=0;
      Step=0.;
      break;
    }
    

    An=A[0]*SU[0]+A[1]*SU[1]+A[2]*SU[2];

    if(fabs(An) < 1.E-6) {
      error=true; 
      Step=0; 
      break;
    }
    
    if( plane.inActive(TVector3(R[0],R[1],R[2]),TVector3(A[0],A[1],A[2]))) {
      Dis=SU[3]-R[0]*SU[0]-R[1]*SU[1]-R[2]*SU[2];
      Step=Dis/An; 
    }
    else{
      if( (O.X()-R[0])*A[0] + (O.Y()-R[1])*A[1] + (O.Z()-R[2])*A[2] >0 ){
        Dis = sqrt((R[0]-O.X())*(R[0]-O.X())+
                   (R[1]-O.Y())*(R[1]-O.Y())+
                   (R[2]-O.Z())*(R[2]-O.Z()));      
      }
      else{
        Dis = -1.*sqrt((R[0]-O.X())*(R[0]-O.X())+
                       (R[1]-O.Y())*(R[1]-O.Y())+
                       (R[2]-O.Z())*(R[2]-O.Z()));            
      }
      Step = Dis; // signed distance to surface
    }

    if (Dis*Dist>0 && fabs(Dis)>fabs(Dist)) { // did not get closer to surface
      error=true; 
      Step=0; 
      break;
    }
    Dist=Dis;

    //
    // reset & check step size
    //
    // reset S to Step if extrapolation too long or in wrong direction
    if (S*Step<0. || fabs(S)>fabs(Step)) S=Step;
    else if (EST<DLT32 && fabs(2.*S)<=Smax) S*=2.;     
    
  } //end of main loop
  
  //
  // Output information preparation for main track parameteres
  //
  
  if (!stopBecauseOfMaterial) { // linear extrapolation to surface
    if(fabs(Sl) > 1.E-12) Sl=1./Sl;           // Sl = inverted last Stepsize Sl
    A [0]+=(SA[0]*=Sl)*Step;    // Step  = distance to surface
    A [1]+=(SA[1]*=Sl)*Step;    // SA*Sl = delta A / delta way; local derivative of A with respect to the length of the way
    A [2]+=(SA[2]*=Sl)*Step;    // A = A + Step * SA*Sl

    P[0]      = R[0]+Step*(A[0]-.5*Step*SA[0]);    // P = R + Step*(A - 1/2*Step*SA); approximation for final point on surface                           
    P[1]      = R[1]+Step*(A[1]-.5*Step*SA[1]);
    P[2]      = R[2]+Step*(A[2]-.5*Step*SA[2]);
      
    points.push_back(TVector3(P[0],P[1],P[2]));
    pointPaths.push_back(Step);
  }
  
  double CBA = 1./sqrt(A[0]*A[0]+A[1]*A[1]+A[2]*A[2]);
  
  P[3]      = A[0]*CBA; // normalize A
  P[4]      = A[1]*CBA;
  P[5]      = A[2]*CBA;
   
  //
  // Output derivatives of track parameters preparation 
  //
  An = A[0]*SU[0]+A[1]*SU[1]+A[2]*SU[2]; 
  fabs(An) < 1.E-6 ? An=1./An : An = 0; // 1/A_normal
  
  if(calcCov && !stopBecauseOfMaterial){
    for(int i=7; i!=ND; i+=7) {
      double* dR = &P[i];  double* dA = &P[i+3];        
      S = (dR[0]*SU[0]+dR[1]*SU[1]+dR[2]*SU[2])*An;     // dR_normal / A_normal
      dR[0]-=S*A [0];  dR[1]-=S*A [1]; dR[2]-=S*A [2]; 
      dA[0]-=S*SA[0];  dA[1]-=S*SA[1]; dA[2]-=S*SA[2]; 
    }
  }
  
  if(error){
    std::cerr << "RKTrackRep::RKutta ==> Do not get closer. Path = " << Way << " cm" << "  p/q = " << 1./P[6] << " GeV" << std::endl;
    return(false);
  }

  // calculate covered distance
  if (!stopBecauseOfMaterial) coveredDistance=Way2+Step;
  else coveredDistance=Way2;

  return(true);
}

void GFAbsTrackRep::setChiSqu ( double  aChiSqu )

inlineinherited

Definition at line 297 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fChiSqu.

Referenced by GFKalman::fittingPass().

                                        {
    fChiSqu = aChiSqu;
  }

void GFAbsTrackRep::setCov ( const TMatrixT< double > &  aCov )

inlineinherited

Definition at line 273 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fCov.

Referenced by GFTrack::blowUpCovs().

                                                   {
    fCov=aCov;
  }

void RKTrackRep::setData ( const TMatrixT< double > &  st, const GFDetPlane &  pl, const TMatrixT< double > *  cov = NULL, const TMatrixT< double > *  aux = NULL  )

virtual

Sets state, plane and (optionally) covariance.

This function also sets the parameter fSpu to the value stored in fCacheSpu. Therefore it has to be ensured that the plane #pl is the same as the plane of the last extrapolation (i.e. fCachePlane), where fCacheSpu was calculated. Hence, if the argument #pl is not equal to fCachePlane, an error message is shown an an exception is thrown.

Reimplemented from GFAbsTrackRep.

Definition at line 43 of file RKTrackRep.cxx.

References fCachePlane, fCacheSpu, fCharge, fSpu, GFAbsTrackRep::fState, and GFAbsTrackRep::setData().

                                                                                                                                  {
  if(aux != NULL) {
    fCacheSpu = (*aux)(0,0);
  } else {
    if(pl!=fCachePlane){
      std::cerr << "RKTrackRep::setData() - a fatal error ocurred! It was called with a reference plane which is not the same as the one from the last extrapolate(plane,state,cov)-> abort in line " << __LINE__ << std::endl;
      throw;
        }
  }
  GFAbsTrackRep::setData(st,pl,cov);
  if (fCharge*fState[0][0] < 0) fCharge *= -1; // set charge accordingly! (fState[0][0] = q/p)
  fSpu=fCacheSpu;
}

void GFAbsTrackRep::setFirstCov ( const TMatrixT< double > &  aCov )

inlineinherited

Definition at line 279 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fFirstCov.

                                                        {
    fFirstCov = aCov;
  }

void GFAbsTrackRep::setFirstPlane ( const GFDetPlane &  aPlane )

inlineinherited

Definition at line 282 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fFirstPlane.

                                                      {
    fFirstPlane = aPlane;;
  }

void GFAbsTrackRep::setFirstState ( const TMatrixT< double > &  aState )

inlineinherited

Definition at line 276 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fFirstState.

                                                            {
    fFirstState = aState;
  }

bool GFAbsTrackRep::setInverted ( bool  f = true )

inlineinherited

Deprecated. Should be removed soon.

Definition at line 316 of file GFAbsTrackRep.h.

References f, and GFAbsTrackRep::fInverted.

{fInverted=f; return true;}

void GFAbsTrackRep::setLastCov ( const TMatrixT< double > &  aCov )

inlineinherited

Definition at line 288 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fLastCov.

                                                       {
    fLastCov = aCov;
  }

void GFAbsTrackRep::setLastPlane ( const GFDetPlane &  aPlane )

inlineinherited

Definition at line 291 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fLastPlane.

                                                     {
    fLastPlane = aPlane;;
  }

void GFAbsTrackRep::setLastState ( const TMatrixT< double > &  aState )

inlineinherited

Definition at line 285 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fLastState.

                                                           {
    fLastState = aState;
  }

void GFAbsTrackRep::setNDF ( unsigned int  n )

inlineinherited

Definition at line 300 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fNdf, and n.

Referenced by GFKalman::fittingPass().

                                     {
    fNdf = n;
  }

void RKTrackRep::setPDG

(

int

i

)

Set PDG particle code.

Definition at line 274 of file RKTrackRep.cxx.

References exit(), fCharge, fMass, fPdg, and i.

Referenced by RKTrackRep().

                            {
  fPdg = i;
  TParticlePDG * part = TDatabasePDG::Instance()->GetParticle(fPdg);
  if(part == 0){
    std::cerr << "RKTrackRep::setPDG particle " << i 
              << " not known to TDatabasePDG -> abort" << std::endl;
    exit(1);
  }
  fMass = part->Mass();
  fCharge = part->Charge()/(3.);
}

void GFAbsTrackRep::setStatusFlag ( int  _val )

inlineinherited

Definition at line 309 of file GFAbsTrackRep.h.

References GFAbsTrackRep::fStatusFlag.

Referenced by GFKalman::fittingPass(), and GFDaf::processTrack().

                                      {
    fStatusFlag = _val;
  }

double RKTrackRep::stepalong ( double  h, TVector3 &  point, TVector3 &  dir  )

virtual

make step of h cm along the track, returns the tracklength spanned in this extrapolation

Also returns the position and direction by reference. It does NOT alter the state of the trackrep and starts extrapolating from fRefPlane.

Reimplemented from GFAbsTrackRep.

Definition at line 1192 of file RKTrackRep.cxx.

References Extrap(), fabs(), GFAbsTrackRep::fRefPlane, fSpu, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), MINSTEP, point, GFDetPlane::setON(), and v.

                                                                  {

  TVector3 dest;

  static const int maxIt(30);

  TVector3 o=fRefPlane.getO();
  TVector3 u=fRefPlane.getU();
  TVector3 v=fRefPlane.getV();
  TVector3 w=u.Cross(v);

  TVector3 pTilde = fSpu* (w + fState[1][0] * u + fState[2][0] * v);
  pTilde.SetMag(1.);

  TVector3 point = o + fState[3][0]*u + fState[4][0]*v;

  TMatrixT<double> state7(7,1);
  state7[0][0] = point.X();
  state7[1][0] = point.Y();
  state7[2][0] = point.Z();
  state7[3][0] = pTilde.X();
  state7[4][0] = pTilde.Y();
  state7[5][0] = pTilde.Z();
  state7[6][0] = fState[0][0];

  double coveredDistance(0.);

  GFDetPlane pl;
  int iterations(0);

  while(true){
    pos.SetXYZ(state7[0][0], state7[1][0], state7[2][0]);
    dir.SetXYZ(state7[3][0], state7[4][0], state7[5][0]);
    dir.SetMag(1.);

    dest = pos + (h - coveredDistance) * dir;

    pl.setON(dest, dir);
    coveredDistance += this->Extrap(pl,&state7);

    if(fabs(h - coveredDistance)<MINSTEP) break;
    if(++iterations == maxIt) {
      GFException exc("RKTrackRep::stepalong ==> maximum number of iterations reached",__LINE__,__FILE__);
      throw exc;
    }
  }
  
  pos.SetXYZ(state7[0][0], state7[1][0], state7[2][0]);
  dir.SetXYZ(state7[3][0], state7[4][0], state7[5][0]);
  dir.SetMag(1.);  
  
  return coveredDistance;

}

void RKTrackRep::switchDirection ( )

inlinevirtual

deprecated

Implements GFAbsTrackRep.

Definition at line 149 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

References fDirection.

{fDirection = (!fDirection);}

Member Data Documentation

TMatrixT<double> RKTrackRep::fAuxInfo

private

Definition at line 211 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Referenced by getAuxInfo().

GFDetPlane RKTrackRep::fCachePlane

private

Definition at line 208 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Referenced by extrapolate(), getAuxInfo(), and setData().

double RKTrackRep::fCacheSpu

private

Definition at line 209 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Referenced by extrapolate(), getAuxInfo(), getMom(), getPosMom(), getPosMomCov(), and setData().

double RKTrackRep::fCharge

private

Charge.

Definition at line 206 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Referenced by Extrap(), getCharge(), getPosMomCov(), RKTrackRep(), RKutta(), setData(), and setPDG().

double GFAbsTrackRep::fChiSqu

protectedinherited

chiSqu of the track fit

Definition at line 94 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::addChiSqu(), GFAbsTrackRep::getChiSqu(), GFAbsTrackRep::Print(), and GFAbsTrackRep::setChiSqu().

TMatrixT<double> GFAbsTrackRep::fCov

protectedinherited

The covariance matrix.

Definition at line 91 of file GFAbsTrackRep.h.

Referenced by GeaneTrackRep::extrapolate(), extrapolate(), GeaneTrackRep::extrapolateToLine(), GeaneTrackRep::extrapolateToPoint(), GeaneTrackRep::GeaneTrackRep(), GFAbsTrackRep::getCov(), GFAbsTrackRep::getCovElem(), GeaneTrackRep::getPocaOnLine(), GeaneTrackRep::getPosMomCov(), getPosMomCov(), GFAbsTrackRep::Print(), GFAbsTrackRep::reset(), RKTrackRep(), GFAbsTrackRep::setCov(), and GFAbsTrackRep::setData().

unsigned int GFAbsTrackRep::fDimension

protectedinherited

Dimensionality of track representation.

Definition at line 85 of file GFAbsTrackRep.h.

Referenced by GeaneTrackRep::extrapolate(), GFAbsTrackRep::extrapolate(), and GFAbsTrackRep::getDim().

bool RKTrackRep::fDirection

private

Definition at line 199 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Referenced by switchDirection().

TMatrixT<double> GFAbsTrackRep::fFirstCov

protectedinherited

Definition at line 104 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getFirstCov(), GFAbsTrackRep::reset(), and GFAbsTrackRep::setFirstCov().

GFDetPlane GFAbsTrackRep::fFirstPlane

protectedinherited

Definition at line 108 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getFirstPlane(), and GFAbsTrackRep::setFirstPlane().

TMatrixT<double> GFAbsTrackRep::fFirstState

protectedinherited

state, cov and plane for first and last point in fit

Definition at line 103 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getFirstState(), GFAbsTrackRep::reset(), and GFAbsTrackRep::setFirstState().

bool GFAbsTrackRep::fInverted

protectedinherited

specifies the direction of flight of the particle

Definition at line 100 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::setInverted().

TMatrixT<double> GFAbsTrackRep::fLastCov

protectedinherited

Definition at line 107 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getLastCov(), GFAbsTrackRep::reset(), and GFAbsTrackRep::setLastCov().

GFDetPlane GFAbsTrackRep::fLastPlane

protectedinherited

Definition at line 109 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getLastPlane(), and GFAbsTrackRep::setLastPlane().

TMatrixT<double> GFAbsTrackRep::fLastState

protectedinherited

Definition at line 106 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getLastState(), GFAbsTrackRep::reset(), and GFAbsTrackRep::setLastState().

double RKTrackRep::fMass

private

Mass (in GeV)

Definition at line 204 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Referenced by setPDG().

unsigned int GFAbsTrackRep::fNdf

protectedinherited

Definition at line 95 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::addNDF(), GFAbsTrackRep::getNDF(), and GFAbsTrackRep::setNDF().

int RKTrackRep::fPdg

private

PDG particle code.

Definition at line 202 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Referenced by Extrap(), getPDG(), RKutta(), and setPDG().

GFDetPlane GFAbsTrackRep::fRefPlane

protectedinherited

Definition at line 112 of file GFAbsTrackRep.h.

Referenced by GeaneTrackRep::extrapolate(), extrapolate(), GeaneTrackRep::extrapolateToLine(), extrapolateToLine(), GeaneTrackRep::extrapolateToPoint(), extrapolateToPoint(), GeaneTrackRep::GeaneTrackRep(), GeaneTrackRep::getMom(), getMom(), GFAbsTrackRep::getMom(), GeaneTrackRep::getPocaOnLine(), GeaneTrackRep::getPos(), getPos(), GFAbsTrackRep::getPos(), GeaneTrackRep::getPosMom(), getPosMom(), GeaneTrackRep::getPosMomCov(), getPosMomCov(), GFAbsTrackRep::getPosMomCov(), GFAbsTrackRep::getReferencePlane(), GFAbsTrackRep::Print(), GFAbsTrackRep::reset(), RKTrackRep(), GFAbsTrackRep::setData(), and stepalong().

double RKTrackRep::fSpu

private

Definition at line 210 of file tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h.

Referenced by extrapolate(), extrapolateToLine(), extrapolateToPoint(), getMom(), getPosMom(), getPosMomCov(), RKTrackRep(), setData(), and stepalong().

TMatrixT<double> GFAbsTrackRep::fState

protectedinherited

The vector of track parameters.

Definition at line 88 of file GFAbsTrackRep.h.

Referenced by GeaneTrackRep::checkState(), GeaneTrackRep::extrapolate(), extrapolate(), GeaneTrackRep::extrapolateToLine(), extrapolateToLine(), GeaneTrackRep::extrapolateToPoint(), extrapolateToPoint(), GeaneTrackRep::GeaneTrackRep(), GeaneTrackRep::getCharge(), GeaneTrackRep::getMom(), getMom(), GeaneTrackRep::getPocaOnLine(), GeaneTrackRep::getPos(), getPos(), GeaneTrackRep::getPosMom(), getPosMom(), GeaneTrackRep::getPosMomCov(), getPosMomCov(), GFAbsTrackRep::getState(), GFAbsTrackRep::getStateElem(), GFAbsTrackRep::Print(), GFAbsTrackRep::reset(), RKTrackRep(), setData(), GFAbsTrackRep::setData(), and stepalong().

int GFAbsTrackRep::fStatusFlag

protectedinherited

status of track representation: 0 means everything's OK

Definition at line 98 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getStatusFlag(), and GFAbsTrackRep::setStatusFlag().

---

The documentation for this class was generated from the following files:

• tracking/GenfitTools/trackrep/RKTrackRep/RKTrackRep.h
• RKTrackRep.cxx