GeaneTrackRep Class Reference

#include <GeaneTrackRep.h>

Inheritance diagram for GeaneTrackRep:

Public Member Functions
	GeaneTrackRep ()
	GeaneTrackRep (FairGeanePro *geane, const GFDetPlane &plane, const TVector3 &mom, const TVector3 &poserr, const TVector3 &momerr, double q, int PDGCode)
	GeaneTrackRep (FairGeanePro *geane, const GFDetPlane &plane, const TVector3 &mom, const TVector3 &poserr, const TVector3 &momerr, int q, int PDGCode)
virtual	~GeaneTrackRep ()
virtual GFAbsTrackRep *	clone () const
virtual GFAbsTrackRep *	prototype () const
virtual double	extrapolate (const GFDetPlane &, TMatrixT< double > &statePred)
	returns the tracklength spanned in this extrapolation More...
virtual double	extrapolate (const GFDetPlane &, TMatrixT< double > &statePred, TMatrixT< double > &covPred)
	Extrapolates the track to the given detectorplane. 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...
TVector3	getPocaOnLine (const TVector3 &p1, const TVector3 &p2, bool back=false)
virtual TVector3	getPos (const GFDetPlane &)
virtual TVector3	getMom (const GFDetPlane &)
virtual void	getPosMom (const GFDetPlane &, TVector3 &pos, TVector3 &mom)
virtual void	getPosMomCov (const GFDetPlane &pl, TVector3 &pos, TVector3 &mom, TMatrixT< double > &cov)
	method which gets position, momentum and 6x6 covariance matrix More...
virtual double	getCharge () const
int	getPropDir ()
FairGeanePro *	getPropagator ()
int	getPDG ()
double	getSPU ()
void	setPropagator (FairGeanePro *g)
void	setPropDir (int d)
void	switchDirection ()
double	extrapolate (const GFDetPlane &plane)
	This changes the state and cov and plane of the rep. More...
virtual double	stepalong (double h, TVector3 &point, TVector3 &dir)
	make step of h cm along the track 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
virtual void	setData (const TMatrixT< double > &st, const GFDetPlane &pl, const TMatrixT< double > *cov=NULL, const TMatrixT< double > *aux=NULL)
	Puts the track representation in a given state. More...
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 ()
virtual bool	hasAuxInfo ()
	See if the track representation has auxillary information stored. More...
virtual const TMatrixT< double > *	getAuxInfo (const GFDetPlane &)
	Get auxillary information from the track representation. More...

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
void	checkState ()

Private Attributes
FairGeanePro *	_geane
int	_pdg
int	_backw
double	_spu

Friends
std::ostream &	operator<< (std::ostream &s, const GeaneTrackRep &me)

Detailed Description

Definition at line 36 of file GeaneTrackRep.h.

Constructor & Destructor Documentation

GeaneTrackRep::GeaneTrackRep

(

)

Definition at line 39 of file GeaneTrackRep.cxx.

Referenced by clone(), and prototype().

  : GFAbsTrackRep(5), _pdg(211),_backw(0), _spu(1)
{

}

GeaneTrackRep::GeaneTrackRep	(	FairGeanePro *	geane,
		const GFDetPlane &	plane,
		const TVector3 &	mom,
		const TVector3 &	poserr,
		const TVector3 &	momerr,
		double	q,
		int	PDGCode
	)

Definition at line 45 of file GeaneTrackRep.cxx.

References _spu, count, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), i, mom, and par.

  : GFAbsTrackRep(5), _geane(geane), _pdg(PDGCode), _backw(0), _spu(1)
{
  FairTrackParP par(plane.getO(),mom,poserr,momerr,(int)TMath::Sign(1.0, q),plane.getO(),plane.getU(),plane.getV());

  _spu=par.GetSPU(); // direction of the momentum

  fState[0][0]=par.GetQp();
  fState[1][0]=par.GetTV();
  fState[2][0]=par.GetTW();
  fState[3][0]=par.GetV();
  fState[4][0]=par.GetW();

  // blow up cov-array: ROOT does not support init with symmetric data
  // See ROOT docu source-file for TMatrixTSym
  // i=row, j=collumn
  double* covarray=par.GetCov();
  int count=0;
  for(int i=0;i<5;++i){
    for(int j=i;j<5;++j){
      fCov[i][j]=covarray[count];
      if(i!=j)fCov[j][i]=covarray[count];
      ++count;
    }
  }
  fRefPlane=plane;
}

GeaneTrackRep::GeaneTrackRep	(	FairGeanePro *	geane,
		const GFDetPlane &	plane,
		const TVector3 &	mom,
		const TVector3 &	poserr,
		const TVector3 &	momerr,
		int	q,
		int	PDGCode
	)

Definition at line 79 of file GeaneTrackRep.cxx.

References _spu, count, GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), i, mom, and par.

  : GFAbsTrackRep(5), _geane(geane), _pdg(PDGCode), _backw(0), _spu(1)
{
  FairTrackParP par(plane.getO(),mom,poserr,momerr,q,plane.getO(),plane.getU(),plane.getV());

  _spu=par.GetSPU(); // direction of the momentum

  fState[0][0]=par.GetQp();
  fState[1][0]=par.GetTV();
  fState[2][0]=par.GetTW();
  fState[3][0]=par.GetV();
  fState[4][0]=par.GetW();

  // blow up cov-array: ROOT does not support init with symmetric data
  // See ROOT docu source-file for TMatrixTSym
  // i=row, j=collumn
  double* covarray=par.GetCov();
  int count=0;
  for(int i=0;i<5;++i){
    for(int j=i;j<5;++j){
      fCov[i][j]=covarray[count];
      if(i!=j)fCov[j][i]=covarray[count];
      ++count;
    }
  }
  fRefPlane=plane;
}

GeaneTrackRep::~GeaneTrackRep ( )

virtual

Definition at line 120 of file GeaneTrackRep.cxx.

{
  
}

Member Function Documentation

void GFAbsTrackRep::addChiSqu ( double  aChiSqu )

inlineinherited

Definition at line 303 of file GFAbsTrackRep.h.

Referenced by GFKalman::processHit().

                                        {
    fChiSqu += aChiSqu;
  }

void GFAbsTrackRep::addNDF ( unsigned int  n )

inlineinherited

Definition at line 306 of file GFAbsTrackRep.h.

References n.

Referenced by GFKalman::processHit().

                                     {
    fNdf += n;
  }

void GeaneTrackRep::checkState ( )

private

Definition at line 526 of file GeaneTrackRep.cxx.

References fabs(), and GFAbsTrackRep::fState.

Referenced by extrapolate(), extrapolateToPoint(), and getPocaOnLine().

                         {
  if(fabs(fState[3][0])<1.E-4)fState[3][0]=1.E-4;
  if(fabs(fState[4][0])<1.E-4)fState[4][0]=1.E-4;
  
  //if (!(fState.Abs()>1.E-15) || !(fState.Abs()<1.E50)){
  //  GFException exc("fState out of numerical bounds",__LINE__,__FILE__);
  //  exc.setFatal();
  //  throw exc;
  //}
}

virtual GFAbsTrackRep* GeaneTrackRep::clone ( ) const

inlinevirtual

Implements GFAbsTrackRep.

Definition at line 60 of file GeaneTrackRep.h.

References GeaneTrackRep().

{return new GeaneTrackRep(*this);}

double GeaneTrackRep::extrapolate ( const GFDetPlane &  plane, TMatrixT< double > &  statePred  )

virtual

returns the tracklength spanned in this extrapolation

There is a default implementation in GFAbsTrackRep.cxx which just drops the predicted covaraiance. If your trackrep has a way to extrapolate without giving a correct cov (that would be faster probably), please overwrite it.

TODO: make this faster by neglecting covariances ?

Reimplemented from GFAbsTrackRep.

Definition at line 129 of file GeaneTrackRep.cxx.

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

{
  TMatrixT<double> covPred(5,5);
  return  extrapolate(pl,statePred,covPred);
}

double GeaneTrackRep::extrapolate ( const GFDetPlane &  plane, TMatrixT< double > &  statePred, TMatrixT< double > &  covPred  )

virtual

Extrapolates the track to the given detectorplane.

Results are put into statePred and covPred This method does NOT alter the state of the object!

Implements GFAbsTrackRep.

Definition at line 139 of file GeaneTrackRep.cxx.

References _backw, _geane, _pdg, _spu, Bool_t, checkState(), count, GFDetPlane::dist(), fabs(), GFAbsTrackRep::fCov, GFAbsTrackRep::fDimension, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, GFAbsTrackRep::getMom(), GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), i, par, Pi, pos, GFException::setFatal(), THETACUT, and v.

{
  if(fabs(getMom(fRefPlane).Theta()/TMath::Pi()*180.) < THETACUT){
    GFException exc("GEANE propagation not possible for p.theta<THETACUT",__LINE__,__FILE__);
    exc.setFatal();
    throw exc;
  }
  statePred.ResizeTo(fDimension,1);
  covPred.ResizeTo(fDimension,fDimension);
  TVector3 o=pl.getO();
  TVector3 u=pl.getU();
  TVector3 v=pl.getV();

  TVector3 ofrom=fRefPlane.getO();
  TVector3 ufrom=fRefPlane.getU();
  TVector3 vfrom=fRefPlane.getV();

  _geane->PropagateFromPlane(ufrom,vfrom);
  _geane->PropagateToPlane(o,u,v);

  FairTrackParP result;
  FairTrackParH result2;
  
  //std::cout<<"Before prop:"<<std::endl;
  //Print();



  double cova[15];
  int count=0;;
  for(int i=0; i<5;++i){
    for(int j=i;j<5;++j){
      cova[count++]=fCov[i][j];
    }
  }
  //protect against low momentum:
  if(fabs(fState[0][0])>200){
    GFException exc("GeaneTrackRep: PROTECT AGAINST LOW MOMENTA",__LINE__,__FILE__);
    exc.setFatal();
    throw exc;
  }

  checkState();
  
  
  FairTrackParP par(fState[3][0],fState[4][0],fState[1][0],fState[2][0],fState[0][0],cova,ofrom,ufrom,vfrom,_spu);
  bool backprop=_backw<0;
  if(_backw==0){
    //Try to guess if we are doing a forward or backward step:
    TVector3 pos(par.GetX(),par.GetY(),par.GetZ());
    TVector3 dir=pl.dist(pos); // direction from pos to plane;
    //Assume B=(0,0,BZ) -> compare signs of dir.Z and mom.Z:
    //backprop= (dir.Z()*par.GetPz())<0 ? true : false;
        backprop= (dir*getMom(fRefPlane))<0;
  }
  if(backprop){
    _geane->setBackProp();
    //std::cout<<"GEANETRACKREP: USING BACKPROPAGATION!" << std::endl;
  }

  Bool_t prop = kTRUE;
  prop = _geane->Propagate(&par,&result,_pdg);   //211
  if (prop==kFALSE){
    GFException exc("GEANE propagation failed",__LINE__,__FILE__);
    //exc.setFatal();
    throw exc;
  }
  

  double l=_geane->GetLengthAtPCA();
 
  statePred[0][0]=result.GetQp();
  statePred[1][0]=result.GetTV();
  statePred[2][0]=result.GetTW();
  statePred[3][0]=result.GetV();
  statePred[4][0]=result.GetW();

  

  double* rescov=result.GetCov();
  count=0;
  for(int i=0;i<5;++i){
    for(int j=i;j<5;++j){
      covPred[i][j]=rescov[count];
      if(i!=j)covPred[j][i]=rescov[count];
      ++count;
    }
  }
  
  //   if(result.GetSPU()!=_spu)std::cout<<"SPU HAS CHANGED! "<<_spu<<" --> "<<result.GetSPU()<<std::endl;
  _spu=result.GetSPU();

  //std::cout<<"AFTER EXTRAPOLATE:"<<std::endl;
  //result.Print();
  //pl.Print();
  //statePred.Print();
  //covPred.Print();
  


  return l;
}

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 GeaneTrackRep::extrapolateToLine ( const TVector3 &  point1, const TVector3 &  point2, TVector3 &  poca, TVector3 &  normVec, TVector3 &  poca_onwire  )

virtual

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

This method extrapolates to the POCA to a line, i.e. a wire. There is a default implementation just like for the extrapolateToPoca for trackReps which do not need this feature, which will abort the execution if it is ever called.

Reimplemented from GFAbsTrackRep.

Definition at line 334 of file GeaneTrackRep.cxx.

References _geane, _pdg, _spu, Double_t, fabs(), GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, GFAbsTrackRep::getMom(), GFDetPlane::getO(), GFAbsTrackRep::getPos(), getPropDir(), GFDetPlane::getU(), GFDetPlane::getV(), i, par, Pi, point, GFException::setFatal(), and THETACUT.

{
  if(fabs(getMom(fRefPlane).Theta()/TMath::Pi()*180.) < THETACUT){
    GFException exc("GEANE propagation not possible for p.theta<THETACUT",__LINE__,__FILE__);
    exc.setFatal();
    throw exc;
  }

  // call propagation to closest approach to a wire 
  Int_t pca = 2;

  // calculate a very large track length 
  TVector3 start = getPos(fRefPlane);
  Double_t distance1, distance2;
  distance1 = (point1 - start).Mag();
  distance2 = (point2 - start).Mag();
  Double_t maxdistance;
  if(distance1 < distance2) maxdistance = distance2;
  else maxdistance = distance1;
  maxdistance *= 2.;  

  // variables for FindPCA:
  TVector3 point(0,0,0);
  Double_t Rad = 0.;
  // poca = vpf = point of closest approach on track
  // poca_onwire = vwi = point of closest approach on wire
  Double_t Di = 0.;
  Float_t trklength = 0.;
  
  // covariance matrix
  FairGeaneUtil util;
  Double_t cov55[5][5];
  for(int i = 0; i < 5; i++) for(int j = 0; j < 5; j++) cov55[i][j] = fCov[i][j];
  Double_t cova[15];
  util.FromMat25ToVec15(cov55, cova);
  
  TVector3 o  = fRefPlane.getO();
  TVector3 dj = fRefPlane.getU();
  TVector3 dk = fRefPlane.getV();
  
  FairTrackParP par(fState[3][0],fState[4][0],fState[1][0],fState[2][0],fState[0][0],cova,o,dj,dk,_spu);

  // get propagation direction
  Int_t direction = getPropDir();
  
  _geane->ActualFindPCA(pca, &par, direction);
  Int_t findpca = _geane->FindPCA(pca, _pdg, point, point1, point2, maxdistance, Rad, poca, poca_onwire, Di, trklength);
  
  if(findpca != 0) {
    GFException exc("findpca failure", __LINE__,__FILE__);      
    throw exc;    
  }

  // dir in poca not filled now
  dirInPoca.SetXYZ(0., 0., 0.);
  
}

void GeaneTrackRep::extrapolateToPoint ( const TVector3 &  point, TVector3 &  poca, TVector3 &  normVec  )

virtual

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

There is an empty implementation of this method in GFAbsTrackRep.cxx, which will just abort with an error message. One can overwrite this method if one wishes to implement a track representation, which should have this feature. An example of an experiment in which you would not need this feature would be track fitting (not so much vertexing) in an experiment with only planar trackers like silicons or planar wire chambers and such. An example where you would need it, would be a TPC where you have to fit the track to space points, or other drift chambers with complicated hit topology.

Reimplemented from GFAbsTrackRep.

Definition at line 247 of file GeaneTrackRep.cxx.

References _backw, _geane, _pdg, _spu, Bool_t, checkState(), count, GFDetPlane::dist(), fabs(), GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, GFAbsTrackRep::getDim(), GFAbsTrackRep::getMom(), GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), i, par, Pi, GFException::setFatal(), and THETACUT.

                                                     {
  if(fabs(getMom(fRefPlane).Theta()/TMath::Pi()*180.) < THETACUT){
    GFException exc("GEANE propagation not possible for p.theta<THETACUT",__LINE__,__FILE__);
    exc.setFatal();
    throw exc;
  }
  int dim = getDim();
  TMatrixT<double> statePred(dim,1);
  TMatrixT<double> covPred(dim,dim);
  //std::cout<<"GeaneTrackRep::extrapolateToPoint"<<std::endl;
  //fRefPlane.Print();

  TVector3 ofrom=fRefPlane.getO();
  TVector3 ufrom=fRefPlane.getU();
  TVector3 vfrom=fRefPlane.getV();

  _geane->SetPoint(pos);
  _geane->PropagateFromPlane(ufrom,vfrom);

  double cova[15];
  int count=0;;
  for(int i=0; i<5;++i){
    for(int j=i;j<5;++j){
      cova[count++]=fCov[i][j];
    }
  }
  //protect against low momentum:
  if(fabs(fState[0][0])>200){
    GFException exc("GeaneTrackRep: PROTECT AGAINST LOW MOMENTA",__LINE__,__FILE__);
    exc.setFatal();
    throw exc;
  }

  checkState();
    
  FairTrackParP par(fState[3][0],fState[4][0],fState[1][0],fState[2][0],fState[0][0],cova,ofrom,ufrom,vfrom,_spu);
  //par.Print();
  bool backprop=_backw<0;
  if(_backw==0){
    // check if new point is after or before my position
    TVector3 dir=fRefPlane.dist(pos); // direction from pos to plane;
        backprop= (dir*getMom(fRefPlane))>0;
  }
  if(!backprop){ // point lies in same direction of flight as momentum
    //std::cout<<" Propagate in flight direction"<<std::endl;
    _geane->PropagateToVirtualPlaneAtPCA(1);
  }
  else{
    //std::cout<<" backPropagate"<<std::endl;
    _geane->BackTrackToVirtualPlaneAtPCA(1);
  }

  FairTrackParP result;
  Bool_t prop = kTRUE;
  prop = _geane->Propagate(&par,&result,_pdg);   //211
  if (prop==kFALSE) {
    GFException exc("GEANE propagation failed",__LINE__,__FILE__);
    //exc.setFatal();
    throw exc;
    //pl=fRefPlane;
    //return pos;
  }

  statePred[0][0]=result.GetQp();
  statePred[1][0]=result.GetTV();
  statePred[2][0]=result.GetTW();
  statePred[3][0]=result.GetV();
  statePred[4][0]=result.GetW();

  double* rescov=result.GetCov();
  count=0;
  for(int i=0;i<5;++i){
    for(int j=i;j<5;++j){
      covPred[i][j]=rescov[count];
      if(i!=j)covPred[j][i]=rescov[count];
      ++count;
    }
  }

  poca.SetXYZ(result.GetX(),result.GetY(),result.GetZ());
  dirInPoca = result.GetJVer().Cross( result.GetKVer() );
}

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

inlinevirtualinherited

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 in RKTrackRep.

Definition at line 342 of file GFAbsTrackRep.h.

Referenced by GFKalman::processHit().

                                                                { //(const GFDetPlane& pl)
          return NULL;
  }

virtual double GeaneTrackRep::getCharge ( ) const

inlinevirtual

Implements GFAbsTrackRep.

Definition at line 101 of file GeaneTrackRep.h.

References GFAbsTrackRep::fState.

Referenced by PndHypMicroWriter::Exec().

{return fState[0][0] > 0 ? 1.: -1.;}

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 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 GeaneTrackRep::getMom ( const GFDetPlane &  pl )

virtual

Implements GFAbsTrackRep.

Definition at line 467 of file GeaneTrackRep.cxx.

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

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

TVector3 GFAbsTrackRep::getMom ( )

inlineinherited

Definition at line 221 of file GFAbsTrackRep.h.

References GFAbsTrackRep::getMom().

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

{return getMom(fRefPlane);}

unsigned int GFAbsTrackRep::getNDF ( ) const

inlineinherited

Definition at line 252 of file GFAbsTrackRep.h.

References GFAbsTrackRep::getDim().

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

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

int GeaneTrackRep::getPDG ( )

inline

Definition at line 104 of file GeaneTrackRep.h.

References _pdg.

{return _pdg;};

TVector3 GeaneTrackRep::getPocaOnLine	(	const TVector3 &	p1,
		const TVector3 &	p2,
		bool	back = false
	)

Definition at line 402 of file GeaneTrackRep.cxx.

References _geane, _pdg, _spu, Bool_t, checkState(), count, fabs(), GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), i, par, and GFException::setFatal().

                                                                             {
  
  //std::cout<<"GeaneTrackRep::getPocaToWire"<<std::endl;

  TVector3 ofrom=fRefPlane.getO();
  TVector3 ufrom=fRefPlane.getU();
  TVector3 vfrom=fRefPlane.getV();

  _geane->SetWire(p1,p2);
  _geane->PropagateFromPlane(ufrom,vfrom);
  double cova[15];
  int count=0;;
  for(int i=0; i<5;++i){
    for(int j=i;j<5;++j){
      cova[count++]=fCov[i][j];
    }
  }
  // protect against low momentum:
  if(fabs(fState[0][0])>200){
    GFException exc("GeaneTrackRep: PROTECT AGAINST LOW MOMENTA",__LINE__,__FILE__);
    exc.setFatal();
    throw exc;
  }

  checkState();
    
  FairTrackParP par(fState[3][0],fState[4][0],fState[1][0],fState[2][0],fState[0][0],cova,ofrom,ufrom,vfrom,_spu);

  
  if(!back){ // point lies in same direction of flight as momentum
    //std::cout<<" Propagate in flight direction"<<std::endl;
    _geane->PropagateToVirtualPlaneAtPCA(2); // option 2 means wire!
  }
  else{
    //std::cout<<" backPropagate"<<std::endl;
    _geane->BackTrackToVirtualPlaneAtPCA(2);
  }

  FairTrackParP result;
  Bool_t prop = kTRUE;

  prop = _geane->Propagate(&par,&result,_pdg);
  if (prop==kFALSE) {
    GFException exc("GEANE propagation failed",__LINE__,__FILE__);
    //exc.setFatal();
    throw exc;
  }

  return _geane->GetPCAOnWire();
}

TVector3 GeaneTrackRep::getPos ( const GFDetPlane &  pl )

virtual

Implements GFAbsTrackRep.

Definition at line 459 of file GeaneTrackRep.cxx.

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

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

TVector3 GFAbsTrackRep::getPos ( )

inlineinherited

Definition at line 220 of file GFAbsTrackRep.h.

References GFAbsTrackRep::getPos().

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

{return getPos(fRefPlane);}

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

virtual

Implements GFAbsTrackRep.

Definition at line 477 of file GeaneTrackRep.cxx.

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

{
  TMatrixT<double> statePred(fState);
  if(pl!=fRefPlane)extrapolate(pl,statePred);
  mom = 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 GeaneTrackRep::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 489 of file GeaneTrackRep.cxx.

References _spu, extrapolate(), fabs(), GFAbsTrackRep::fCov, GFAbsTrackRep::fRefPlane, GFAbsTrackRep::fState, GFDetPlane::getNormal(), GFDetPlane::getO(), GFDetPlane::getU(), GFDetPlane::getV(), and i.

                                                                                                 {
  cov.ResizeTo(6,6);

  TMatrixT<double> statePred(fState), covPred(fCov);
  if(pl!=fRefPlane)extrapolate(pl, statePred, covPred);

  // position
  pos = pl.getO()+(statePred[3][0]*pl.getU())+(statePred[4][0]*pl.getV());

  // momentum
  double fSPU  = _spu;
  mom = fSPU*pl.getNormal()+fSPU*statePred[1][0]*pl.getU()+fSPU*statePred[2][0]*pl.getV();
  mom.SetMag(1./fabs(statePred[0][0]));
  
  // covariance matrix
  FairGeaneUtil util;
  // covPred 5 X 5 ==> cov55[5][5]
  double cov55[5][5];
  for(int i = 0; i < 5; i++) for(int j = 0; j < 5; j++) cov55[i][j] = covPred[i][j];
  // cov55[5][5] ==> cov15[15]
  double cov15[15];
  util.FromMat25ToVec15(cov55, cov15);
  
  FairTrackParP parPred(statePred[3][0], 
                        statePred[4][0], statePred[1][0], 
                        statePred[2][0], statePred[0][0], 
                        cov15, 
                        pl.getO(), pl.getU(), pl.getV(), 
                        _spu);
  double cov66[6][6];
  parPred.GetMARSCov(cov66);
  for(int i = 0; i < 6; i++) for(int j = 0; j < 6; j++) cov[i][j] = cov66[i][j];
 
}

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

inlineinherited

Definition at line 222 of file GFAbsTrackRep.h.

References GFAbsTrackRep::getPosMomCov().

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

FairGeanePro* GeaneTrackRep::getPropagator ( )

inline

Definition at line 103 of file GeaneTrackRep.h.

References _geane.

{return _geane;}

int GeaneTrackRep::getPropDir ( )

inline

Definition at line 102 of file GeaneTrackRep.h.

References _backw.

Referenced by extrapolateToLine().

{return _backw;} 

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

double GeaneTrackRep::getSPU ( )

inline

Definition at line 105 of file GeaneTrackRep.h.

References _spu.

{return _spu;}

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

virtual bool GFAbsTrackRep::hasAuxInfo ( )

inlinevirtualinherited

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 in RKTrackRep.

Definition at line 329 of file GFAbsTrackRep.h.

Referenced by GFDaf::copySmoothing(), GFTools::getBiasedSmoothedData(), GFTools::getSmoothedData(), GFKalman::processHit(), and GFKalman::processTrack().

                            {
          return false;
  }

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* GeaneTrackRep::prototype ( ) const

inlinevirtual

Implements GFAbsTrackRep.

Definition at line 61 of file GeaneTrackRep.h.

References GeaneTrackRep().

{return new GeaneTrackRep();}

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();
}

void GFAbsTrackRep::setChiSqu ( double  aChiSqu )

inlineinherited

Definition at line 297 of file GFAbsTrackRep.h.

Referenced by GFKalman::fittingPass().

                                        {
    fChiSqu = aChiSqu;
  }

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

inlineinherited

Definition at line 273 of file GFAbsTrackRep.h.

Referenced by GFTrack::blowUpCovs().

                                                   {
    fCov=aCov;
  }

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

inlinevirtualinherited

Puts the track representation in a given state.

This is used to update the track representation after the update of the Kalman filter was calculated.

IMPORTANT: One should be able to set the track representation to arbitraty values using this method. If the track representation needs additional information beside the state vector, the plane and the covariance, it has to be handed over via the "aux" Matrix. GFAbsTrackRep::getAuxInfo() should return the appropriate information. This is mandatory if smoothing is used.

Reimplemented in RKTrackRep.

Definition at line 267 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::extrapolate(), GFTools::getBiasedSmoothedData(), GFTools::getSmoothedData(), GFKalman::processHit(), and RKTrackRep::setData().

                                                                                                                                            {
    fState=st;
    fRefPlane=pl;
    if(cov!=NULL) fCov=*cov;
    if(aux!=NULL) {;}
  }

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

inlineinherited

Definition at line 279 of file GFAbsTrackRep.h.

                                                        {
    fFirstCov = aCov;
  }

void GFAbsTrackRep::setFirstPlane ( const GFDetPlane &  aPlane )

inlineinherited

Definition at line 282 of file GFAbsTrackRep.h.

                                                      {
    fFirstPlane = aPlane;;
  }

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

inlineinherited

Definition at line 276 of file GFAbsTrackRep.h.

                                                            {
    fFirstState = aState;
  }

bool GFAbsTrackRep::setInverted ( bool  f = true )

inlineinherited

Deprecated. Should be removed soon.

Definition at line 316 of file GFAbsTrackRep.h.

References f.

{fInverted=f; return true;}

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

inlineinherited

Definition at line 288 of file GFAbsTrackRep.h.

                                                       {
    fLastCov = aCov;
  }

void GFAbsTrackRep::setLastPlane ( const GFDetPlane &  aPlane )

inlineinherited

Definition at line 291 of file GFAbsTrackRep.h.

                                                     {
    fLastPlane = aPlane;;
  }

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

inlineinherited

Definition at line 285 of file GFAbsTrackRep.h.

                                                           {
    fLastState = aState;
  }

void GFAbsTrackRep::setNDF ( unsigned int  n )

inlineinherited

Definition at line 300 of file GFAbsTrackRep.h.

References n.

Referenced by GFKalman::fittingPass().

                                     {
    fNdf = n;
  }

void GeaneTrackRep::setPropagator ( FairGeanePro *  g )

inline

Definition at line 107 of file GeaneTrackRep.h.

References _geane, and g.

{_geane=g;}

void GeaneTrackRep::setPropDir ( int  d )

inline

Definition at line 108 of file GeaneTrackRep.h.

References _backw, and d.

Referenced by PndHypDKalmanTask::Exec(), PndRecoDafFit::Fit(), and PndRecoKalmanFit::Fit().

{_backw=d;} 

void GFAbsTrackRep::setStatusFlag ( int  _val )

inlineinherited

Definition at line 309 of file GFAbsTrackRep.h.

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

                                      {
    fStatusFlag = _val;
  }

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

virtualinherited

make step of h cm along the track

There is an emply implementation in GFAbsTrackRep.cxx which will abort (see one of the extrapolate methods above). This can be overwritten, if this feature is needed.

Reimplemented in RKTrackRep.

Definition at line 71 of file GFAbsTrackRep.cxx.

References GFAbsTrackRep::Abort().

Referenced by trackProximity().

                             {//TVector3& dir){
  Abort("stepalong()");
  return -1.;
}

void GeaneTrackRep::switchDirection ( )

inlinevirtual

Implements GFAbsTrackRep.

Definition at line 109 of file GeaneTrackRep.h.

References _backw.

{_backw=-_backw;}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  s, const GeaneTrackRep &  me  )

friend

Member Data Documentation

int GeaneTrackRep::_backw

private

Definition at line 120 of file GeaneTrackRep.h.

Referenced by extrapolate(), extrapolateToPoint(), getPropDir(), setPropDir(), and switchDirection().

FairGeanePro* GeaneTrackRep::_geane

private

Definition at line 118 of file GeaneTrackRep.h.

Referenced by extrapolate(), extrapolateToLine(), extrapolateToPoint(), getPocaOnLine(), getPropagator(), and setPropagator().

int GeaneTrackRep::_pdg

private

Definition at line 119 of file GeaneTrackRep.h.

Referenced by extrapolate(), extrapolateToLine(), extrapolateToPoint(), getPDG(), and getPocaOnLine().

double GeaneTrackRep::_spu

private

Definition at line 121 of file GeaneTrackRep.h.

Referenced by extrapolate(), extrapolateToLine(), extrapolateToPoint(), GeaneTrackRep(), getMom(), getPocaOnLine(), getPosMomCov(), and getSPU().

double GFAbsTrackRep::fChiSqu

protectedinherited

chiSqu of the track fit

Definition at line 94 of file GFAbsTrackRep.h.

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

TMatrixT<double> GFAbsTrackRep::fCov

protectedinherited

The covariance matrix.

Definition at line 91 of file GFAbsTrackRep.h.

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

unsigned int GFAbsTrackRep::fDimension

protectedinherited

Dimensionality of track representation.

Definition at line 85 of file GFAbsTrackRep.h.

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

TMatrixT<double> GFAbsTrackRep::fFirstCov

protectedinherited

Definition at line 104 of file GFAbsTrackRep.h.

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

GFDetPlane GFAbsTrackRep::fFirstPlane

protectedinherited

Definition at line 108 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getFirstPlane().

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(), and GFAbsTrackRep::reset().

bool GFAbsTrackRep::fInverted

protectedinherited

specifies the direction of flight of the particle

Definition at line 100 of file GFAbsTrackRep.h.

TMatrixT<double> GFAbsTrackRep::fLastCov

protectedinherited

Definition at line 107 of file GFAbsTrackRep.h.

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

GFDetPlane GFAbsTrackRep::fLastPlane

protectedinherited

Definition at line 109 of file GFAbsTrackRep.h.

Referenced by GFAbsTrackRep::getLastPlane().

TMatrixT<double> GFAbsTrackRep::fLastState

protectedinherited

Definition at line 106 of file GFAbsTrackRep.h.

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

unsigned int GFAbsTrackRep::fNdf

protectedinherited

Definition at line 95 of file GFAbsTrackRep.h.

GFDetPlane GFAbsTrackRep::fRefPlane

protectedinherited

Definition at line 112 of file GFAbsTrackRep.h.

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

TMatrixT<double> GFAbsTrackRep::fState

protectedinherited

The vector of track parameters.

Definition at line 88 of file GFAbsTrackRep.h.

Referenced by checkState(), extrapolate(), RKTrackRep::extrapolate(), extrapolateToLine(), RKTrackRep::extrapolateToLine(), extrapolateToPoint(), RKTrackRep::extrapolateToPoint(), GeaneTrackRep(), getCharge(), getMom(), RKTrackRep::getMom(), getPocaOnLine(), getPos(), RKTrackRep::getPos(), getPosMom(), RKTrackRep::getPosMom(), getPosMomCov(), RKTrackRep::getPosMomCov(), GFAbsTrackRep::getState(), GFAbsTrackRep::getStateElem(), GFAbsTrackRep::Print(), GFAbsTrackRep::reset(), RKTrackRep::RKTrackRep(), RKTrackRep::setData(), and RKTrackRep::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().

---

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

• GeaneTrackRep.h
• GeaneTrackRep.cxx