AFPSiDBasicKalmanToolTrack Class Reference

Class representing a reconstructed track with Kalman filter. More...

#include <AFPSiDBasicKalmanToolTrack.h>

Collaboration diagram for AFPSiDBasicKalmanToolTrack:

Public Member Functions
	AFPSiDBasicKalmanToolTrack (const xAOD::AFPSiHitsCluster *firstCluster, const xAOD::AFPSiHitsCluster *secondCluster, const CLHEP::HepMatrix &observationModel, const CLHEP::HepMatrix &observationNoise, const CLHEP::HepMatrix &covarianceMatrix)
	Main constructor that creates the track seed from two clusters.
CLHEP::HepMatrix	transitionModel (const double firstPos, const double secondPos) const
	Create state transition matrix to calculate x and y position and slopes between to Z positions.
CLHEP::HepMatrix	transitionModel (const double zPosition) const
	Create state transition matrix to calculate x and y position and slopes at given Z.
CLHEP::HepVector	predictNextPoint (const double zPosition) const
	Predict x and y positions and slopes of the track at given Z.
CLHEP::HepMatrix	predictNextPointCov (const double zPosition) const
	Predict covariance matrix of the track at given Z.
const xAOD::AFPSiHitsCluster *	findNearestCluster (const std::vector< const xAOD::AFPSiHitsCluster * > &clusters, const float maxAllowedDistance) const
	Finds the cluster which is nearest to the track, returns nullptr if no is found.
void	addCluster (const xAOD::AFPSiHitsCluster *cluster, const float htiMaxChi2)
	Adds a new cluster to the track and updates history and position.
int	holes () const
void	addHole ()
	Increase number of holes by 1. (see m_holes)
const std::list< const xAOD::AFPSiHitsCluster * > &	clustersInTrack () const
	Clusters used to reconstruct the track.
void	clearSmoothMatrices ()
	Clears matrices used for smoothing the track.
const std::list< CLHEP::HepVector > &	positionAndSlopeSmooth () const
	Vectors of reconstructed true positions for each step after smoothing \(x_{k}\).
const std::list< CLHEP::HepVector > &	positionAndSlopeHistory () const
	Vectors of reconstructed true positions for each step \(x_{k}\).
const std::list< double > &	chi2Smooth () const
	History of chi2 for each step after smoothing.
double	trkChi2NDFSmooth () const
	Chi2 per degrees of freedom (clusters) for the whole smoothed track.
void	smooth ()
	Run smoothing algorithm.

Protected Attributes
std::list< float >	m_zPositionHistory
	Vectors of reconstructed true positions for each step.
std::list< CLHEP::HepVector >	m_positionAndSlopeHistory
	Vectors of reconstructed true positions for each step \(x_{k}\).
std::list< CLHEP::HepVector >	m_positionAndSlopePredictedHistory
	Vectors of predicted true position of a track for each step.
std::list< CLHEP::HepMatrix >	m_positionAndSlopeCovHistory
	Matrices of updated (a posteriori) estimate covariance of the position and slope for each step \(P_{k|k}\).
std::list< CLHEP::HepMatrix >	m_positionAndSlopeCovPredictedHistory
	Matrices of predicted estimate covariance of the position and slope for each step.
std::list< CLHEP::HepMatrix >	m_transitionHistory
	Matrices of transitionModel used at each step of track reconstruction.
std::list< double >	m_chi2History
	History of chi2 for each step.
std::list< CLHEP::HepVector >	m_positionAndSlopeSmooth
	Vectors of reconstructed true positions for each step after smoothing \(x_{k}\).
std::list< CLHEP::HepMatrix >	m_positionAndSlopeSmoothCov
	Matrices of updated (a posteriori) estimate covariance of the position and slope for each step after smoothing \(P_{k|k}\).
std::list< double >	m_chi2Smooth
	History of chi2 for each step after smoothing.
std::list< const xAOD::AFPSiHitsCluster * >	m_clustersInTrack
	Clusters used to reconstruct the track.
const CLHEP::HepMatrix &	m_observationModel
	Observation model, describing transformation from true to measured state.
const CLHEP::HepMatrix &	m_observationNoise
	Matrix representing observation noise disturbing the measurement.
int	m_holes
	Number of layers in which hit from a track is expected, but is not present.

Detailed Description

Class representing a reconstructed track with Kalman filter.

Definition at line 23 of file AFPSiDBasicKalmanToolTrack.h.

Constructor & Destructor Documentation

AFPSiDBasicKalmanToolTrack()

AFPSiDBasicKalmanToolTrack::AFPSiDBasicKalmanToolTrack	(	const xAOD::AFPSiHitsCluster *	firstCluster,
		const xAOD::AFPSiHitsCluster *	secondCluster,
		const CLHEP::HepMatrix &	observationModel,
		const CLHEP::HepMatrix &	observationNoise,
		const CLHEP::HepMatrix &	covarianceMatrix )

Main constructor that creates the track seed from two clusters.

It adds the two clusters to the list of clusters used to reconstruct the track. It sets the position of the last point of the track to be equal to the position of the second cluster and calculates track slopes using first and second clusters. It adds first entry to m_chi2History and sets it to 0.

Parameters

firstCluster	pointer to the first cluster of the track
secondCluster	pointer to the second cluster of the track
observationModel	matrix representing observation model (see m_observationModel)
observationNoise	see m_observationNoise
covarianceMatrix	initial error covariance matrix (see m_positionAndSlopeCovHistory)

Definition at line 19 of file AFPSiDBasicKalmanToolTrack.cxx.

                                                                                                                                                                                                                                                                   :
  m_observationModel(observationModel),
  m_observationNoise(observationNoise),
  m_holes(0)
{
  m_positionAndSlopeHistory.emplace_back(4);
 
  const double zDistance = secondCluster->zLocal() - firstCluster->zLocal(); // absolute value taken in case global z position is used, in that case the distance would be negative for stations on the A side
  
  CLHEP::HepVector& positionAndSlope = m_positionAndSlopeHistory.back();
  positionAndSlope[0] = secondCluster->xLocal(); // set track X position 
  positionAndSlope[1] = (secondCluster->xLocal() - firstCluster->xLocal())/zDistance; // set track X slope
  positionAndSlope[2] = secondCluster->yLocal(); // set track Y position
  positionAndSlope[3] = (secondCluster->yLocal() - firstCluster->yLocal())/zDistance; // set track Y slope
 
  // set z position of the track
  m_zPositionHistory.push_back(secondCluster->zLocal());
 
  // add clusters to the list 
  m_clustersInTrack.push_back(firstCluster);
  m_clustersInTrack.push_back(secondCluster);
 
  // set the first covariance matrix
  m_positionAndSlopeCovHistory.emplace_back(covarianceMatrix);
 
  // set chi2 to 0 for two points
  m_chi2History.emplace_back(0);
}

Member Function Documentation

addCluster()

void AFPSiDBasicKalmanToolTrack::addCluster	(	const xAOD::AFPSiHitsCluster *	cluster,
		const float	htiMaxChi2 )

Adds a new cluster to the track and updates history and position.

Definition at line 48 of file AFPSiDBasicKalmanToolTrack.cxx.

{
  // prepare a vector with new observation point coordinates
  CLHEP::HepVector newPoint (2);
  newPoint[0] = cluster->xLocal();
  newPoint[1] = cluster->yLocal();
 
  // get the values for the predicted new point
  const double newZ = cluster->zLocal();
 
  const CLHEP::HepVector predictedTruePosition = predictNextPoint(newZ);
  const CLHEP::HepMatrix predictedCovariance = predictNextPointCov(newZ);
 
  // difference between measured and predicted (called innovation y_k and S_k)
  const CLHEP::HepVector residualPredicted = newPoint - m_observationModel*predictedTruePosition;
  const CLHEP::HepMatrix residualPredictedCov = m_observationNoise + m_observationModel*predictedCovariance*m_observationModel.T();
 
  // optimal Kalman gain (Kk)
  const CLHEP::HepMatrix kalmanGain = predictedCovariance*m_observationModel.T()*qr_inverse(residualPredictedCov);
 
  // === calculated new values ===
  // Updated (a posteriori) state estimate
  const CLHEP::HepVector newPosition = predictedTruePosition + kalmanGain*residualPredicted;
 
  // Updated (a posteriori) residuals
  const CLHEP::HepVector newResidual = newPoint - m_observationModel*newPosition;
  const CLHEP::HepMatrix newResidualCov = m_observationNoise - m_observationModel*kalmanGain*m_observationNoise;
 
  // chi2 statistics
  const CLHEP::HepVector chi2Vector = newResidual.T()*qr_inverse(newResidualCov)*newResidual;
 
  // check if hit is good
  if (chi2Vector[0] < clusterMaxChi2) {
    // add cluster and all information
    m_clustersInTrack.push_back(cluster);
    m_zPositionHistory.push_back(newZ);
    m_transitionHistory.emplace_back(transitionModel(newZ));
    m_positionAndSlopePredictedHistory.push_back(predictedTruePosition);
    m_positionAndSlopeCovPredictedHistory.push_back(predictedCovariance);
    m_positionAndSlopeHistory.push_back(newPosition);
    m_chi2History.emplace_back(chi2Vector[0]);
    // Updated (a posteriori) estimate covariance
    m_positionAndSlopeCovHistory.emplace_back(predictedCovariance - kalmanGain*m_observationModel*predictedCovariance);
  }
  else {
    addHole();
  }
}

addHole()

void AFPSiDBasicKalmanToolTrack::addHole ( )

inline

Increase number of holes by 1. (see m_holes)

Definition at line 97 of file AFPSiDBasicKalmanToolTrack.h.

{++m_holes;}

chi2Smooth()

const std::list< double > & AFPSiDBasicKalmanToolTrack::chi2Smooth ( ) const

inline

History of chi2 for each step after smoothing.

Definition at line 112 of file AFPSiDBasicKalmanToolTrack.h.

{return m_chi2Smooth;}

clearSmoothMatrices()

void AFPSiDBasicKalmanToolTrack::clearSmoothMatrices

(

)

Clears matrices used for smoothing the track.

Definition at line 115 of file AFPSiDBasicKalmanToolTrack.cxx.

{
  m_positionAndSlopeSmooth.clear();
  m_positionAndSlopeSmoothCov.clear();
  m_chi2Smooth.clear();
}

clustersInTrack()

const std::list< const xAOD::AFPSiHitsCluster * > & AFPSiDBasicKalmanToolTrack::clustersInTrack ( ) const

inline

Clusters used to reconstruct the track.

Definition at line 100 of file AFPSiDBasicKalmanToolTrack.h.

{return m_clustersInTrack;}

findNearestCluster()

const xAOD::AFPSiHitsCluster * AFPSiDBasicKalmanToolTrack::findNearestCluster	(	const std::vector< const xAOD::AFPSiHitsCluster * > &	clusters,
		const float	maxAllowedDistance ) const

Finds the cluster which is nearest to the track, returns nullptr if no is found.

The method predicts what are track X and Y coordinates for the Z of a cluster. Next, loops over the clusters in the vector and calculates distance \(r = \sqrt{\Delta x^2 + \Delta y^2}\). Returns nullptr if there is no cluster which is closer than #maxAllowedDistance or if there are clusters with r < #maxAllowedDistance a pointer to the closest one.

Parameters

clusters	vector of clusters from which the closest one is to be found
maxAllowedDistance	if no cluster is closer than this argument nullptr is returned

Definition at line 97 of file AFPSiDBasicKalmanToolTrack.cxx.

{
  double minDisntace = maxAllowedDistance;
  const xAOD::AFPSiHitsCluster* nearestCluster = nullptr;
  for (const xAOD::AFPSiHitsCluster* theCluster : clusters) {
    const CLHEP::HepVector predictedPoint = predictNextPoint(theCluster->zLocal());
    const double xDiff = predictedPoint[0] - theCluster->xLocal();
    const double yDiff = predictedPoint[2] - theCluster->yLocal(); // index 2, because this is (x, dx, y, dy) vector
    const double distance = std::sqrt(xDiff*xDiff + yDiff*yDiff);
    if (distance < minDisntace) {
      minDisntace = distance;
      nearestCluster = theCluster;
    }
  }
 
  return nearestCluster;
}

holes()

int AFPSiDBasicKalmanToolTrack::holes ( ) const

inline

Definition at line 94 of file AFPSiDBasicKalmanToolTrack.h.

{return m_holes;}

positionAndSlopeHistory()

const std::list< CLHEP::HepVector > & AFPSiDBasicKalmanToolTrack::positionAndSlopeHistory ( ) const

inline

Vectors of reconstructed true positions for each step \(x_{k}\).

Each 4D vector containing x, y position of the track in a given step as well as slopes in these two directions \(\Delta x, \Delta y\). \(x_{k} = (x, \Delta x, y, \Delta y)\)

Definition at line 109 of file AFPSiDBasicKalmanToolTrack.h.

{return m_positionAndSlopeHistory;}

positionAndSlopeSmooth()

const std::list< CLHEP::HepVector > & AFPSiDBasicKalmanToolTrack::positionAndSlopeSmooth ( ) const

inline

Vectors of reconstructed true positions for each step after smoothing \(x_{k}\).

Each 4D vector containing x, y position of the track in a given step as well as slopes in these two directions \(\Delta x, \Delta y\). \(x_{k} = (x, \Delta x, y, \Delta y)\)

Definition at line 106 of file AFPSiDBasicKalmanToolTrack.h.

{return m_positionAndSlopeSmooth;}

predictNextPoint()

CLHEP::HepVector AFPSiDBasicKalmanToolTrack::predictNextPoint ( const double zPosition ) const

inline

Predict x and y positions and slopes of the track at given Z.

Definition at line 67 of file AFPSiDBasicKalmanToolTrack.h.

  {return transitionModel(zPosition)*m_positionAndSlopeHistory.back();}

predictNextPointCov()

CLHEP::HepMatrix AFPSiDBasicKalmanToolTrack::predictNextPointCov ( const double zPosition ) const

inline

Predict covariance matrix of the track at given Z.

Definition at line 71 of file AFPSiDBasicKalmanToolTrack.h.

  {CLHEP::HepMatrix transition = transitionModel(zPosition);
    return transition*m_positionAndSlopeCovHistory.back()*transition.T();}

smooth()

void AFPSiDBasicKalmanToolTrack::smooth

(

)

Run smoothing algorithm.

The algorithm should probably just reconstruct track starting from the last hit, but the covaraince matrices are changed, so the result maybe slightly different. Algorithm is just copied from the previous implementation.

Definition at line 122 of file AFPSiDBasicKalmanToolTrack.cxx.

{
  clearSmoothMatrices();
 
  // prepare iterators for going backwards through the lists
  std::list< CLHEP::HepVector >::const_iterator positionIter = m_positionAndSlopeHistory.end();
  std::list< CLHEP::HepVector >::const_iterator positionBegin = m_positionAndSlopeHistory.begin();
  // if no position is reconstructed there is nothing to be done
  if (positionIter != positionBegin) {
    // prepare remaining iterators
    std::list< CLHEP::HepMatrix >::const_iterator covIter = m_positionAndSlopeCovHistory.end();
    std::list< const xAOD::AFPSiHitsCluster* >::const_iterator clustersIter = m_clustersInTrack.end();
    std::list< CLHEP::HepVector >::const_iterator positionPredictIter = m_positionAndSlopePredictedHistory.end();
    std::list< CLHEP::HepMatrix >::const_iterator covPredictIter  = m_positionAndSlopeCovPredictedHistory.end();
    std::list< CLHEP::HepMatrix >::const_iterator transitionIter  = m_transitionHistory.end();
    
    // === prepare first point ===
    // iterator moved back by 1, because end() points after the last element
    const CLHEP::HepVector& lastPosition = *(--positionIter);
    const CLHEP::HepMatrix& lastCovariance = *(--covIter);
    const xAOD::AFPSiHitsCluster* lastCluster = *(--clustersIter);
 
    m_positionAndSlopeSmooth.push_back(lastPosition);
    m_positionAndSlopeSmoothCov.push_back(lastCovariance);
 
    // prepare a vector with new observation point coordinates
    CLHEP::HepVector lastPoint (2);
    lastPoint[0] = lastCluster->xLocal();
    lastPoint[1] = lastCluster->yLocal();
 
    const CLHEP::HepVector residualSmooth = lastPoint - m_observationModel*lastPosition;
    const CLHEP::HepMatrix residualSmoothCov = m_observationNoise - m_observationModel*lastCovariance*m_observationModel.T();
    const CLHEP::HepVector chi2Smooth = residualSmooth.T()*qr_inverse(residualSmoothCov)*residualSmooth;
    m_chi2Smooth.push_back(chi2Smooth[0]);
 
    // === loop over remaining clusters ===
    while (positionIter != positionBegin) { 
      // --- read needed variables ---
      const CLHEP::HepVector& position = *(--positionIter);
      const CLHEP::HepMatrix& covariance = *(--covIter);
      const xAOD::AFPSiHitsCluster* cluster = *(--clustersIter);
 
      // shifted by 1 in history with respect to the position and covariance
      const CLHEP::HepVector& prevPositionPred = *(--positionPredictIter);
      const CLHEP::HepMatrix& prevCovPred = *(--covPredictIter);
      const CLHEP::HepMatrix& prevTransition = *(--transitionIter);
 
      // --- calculate the smoothed position and covariance ---
      const CLHEP::HepMatrix Ai = qr_inverse(prevTransition); // when Qk == 0
      //      const CLHEP::HepMatrix Ai = covariance * prevTransition.T() * qr_inverse(prevCovPred);        
      const CLHEP::HepVector positionSmooth = position + Ai*( m_positionAndSlopeSmooth.back() - prevPositionPred );
      const CLHEP::HepMatrix covarianceSmooth = covariance + Ai*( m_positionAndSlopeSmoothCov.back() - prevCovPred )*Ai.T();
      
      // --- calculate smoothed chi2 ---
      CLHEP::HepVector point (2);
      point[0] = cluster->xLocal();
      point[1] = cluster->yLocal();
      const CLHEP::HepVector residualSmooth = point - m_observationModel*positionSmooth;
      const CLHEP::HepMatrix residualCovSmooth = m_observationNoise - m_observationModel*covarianceSmooth*m_observationModel.T();
      CLHEP::HepVector chi2Smooth = residualSmooth.T()*qr_inverse(residualCovSmooth)*residualSmooth;
 
      // --- add results to the lists ---
      m_positionAndSlopeSmooth.push_back(positionSmooth);
      m_positionAndSlopeSmoothCov.push_back(covarianceSmooth);
      m_chi2Smooth.push_back(chi2Smooth[0]);
    } // end while over points/clusters
 
 
    // === extrapolate to the first plane ===
    clustersIter = m_clustersInTrack.begin();    
    const xAOD::AFPSiHitsCluster* firstCluster = *clustersIter;
    const xAOD::AFPSiHitsCluster* secondCluster = *(++clustersIter);
    const CLHEP::HepMatrix firstTransition = transitionModel(firstCluster->zLocal(), secondCluster->zLocal());
 
    const CLHEP::HepMatrix Ai = qr_inverse(firstTransition); // when Qk == 0
    const CLHEP::HepVector firstPosition = Ai*(m_positionAndSlopeSmooth.back());
    const CLHEP::HepMatrix firstCovariance = m_positionAndSlopeCovHistory.front() + Ai*( m_positionAndSlopeSmoothCov.back() - m_positionAndSlopeCovHistory.front())*Ai.T();
 
    // --- calculate smoothed chi2 ---
    const CLHEP::HepVector firstResidual = m_observationModel*Ai*(m_positionAndSlopeHistory.front() - m_positionAndSlopeSmooth.back());
    CLHEP::HepVector firstPoint (2);
    firstPoint[0] = firstCluster->xLocal();
    firstPoint[1] = firstCluster->yLocal();
    //    const CLHEP::HepVector firstResidual = firstPoint - m_observationModel*firstPosition;
    const CLHEP::HepMatrix firstResidualCov = m_observationNoise - m_observationModel*firstCovariance*m_observationModel.T();
    CLHEP::HepVector firstChi2 = firstResidual.T()*qr_inverse(firstResidualCov)*firstResidual;
 
    // --- add results to the lists ---
    m_positionAndSlopeSmooth.push_back(firstPosition);
    m_positionAndSlopeSmoothCov.push_back(firstCovariance);
    m_chi2Smooth.push_back(firstChi2[0]);
  }
}

transitionModel() [1/2]

CLHEP::HepMatrix AFPSiDBasicKalmanToolTrack::transitionModel ( const double firstPos, const double secondPos ) const

inline

Create state transition matrix to calculate x and y position and slopes between to Z positions.

The matrix leaves slopes unchanged and adds to the previous positions slopes multiplied by the z distance i.e. secondPos - firstPos.

\[\left( \begin{array}{cccc} 1 & \Delta z & 0 & 0 0 & 1 & 0 & 0 0 & 0 & 1 & \Delta z 0 & 0 & 0 & 1 \end{array} \right) \]

Definition at line 187 of file AFPSiDBasicKalmanToolTrack.h.

{
  CLHEP::HepMatrix transitionModel (4, 4, 1);    // create unit matrix (1 on diagonal, 0 offdiagonal)
  const double zDistance = secondPos - firstPos;
  transitionModel[0][1] = zDistance;// set linear transformation which sets x' = x + dx*dz
  transitionModel[2][3] = zDistance; // set linear transformation which sets y' = y + dy*dz
 
  return transitionModel;
}

transitionModel() [2/2]

CLHEP::HepMatrix AFPSiDBasicKalmanToolTrack::transitionModel ( const double zPosition ) const

inline

Create state transition matrix to calculate x and y position and slopes at given Z.

The matrix for transition between the last point and given Z position is calculated.

Definition at line 63 of file AFPSiDBasicKalmanToolTrack.h.

  {return transitionModel (m_zPositionHistory.back(),  zPosition);}

trkChi2NDFSmooth()

double AFPSiDBasicKalmanToolTrack::trkChi2NDFSmooth

(

)

const

Chi2 per degrees of freedom (clusters) for the whole smoothed track.

Sum chi2 for each cluster and divide by the number of clusters.

Definition at line 216 of file AFPSiDBasicKalmanToolTrack.cxx.

{
  double chi2 = 0;
  for (double val : m_chi2Smooth) {
    chi2 += val;
  }
  
  return chi2/m_chi2Smooth.size();
}

Member Data Documentation

m_chi2History

std::list< double> AFPSiDBasicKalmanToolTrack::m_chi2History

protected

History of chi2 for each step.

Definition at line 156 of file AFPSiDBasicKalmanToolTrack.h.

m_chi2Smooth

std::list< double > AFPSiDBasicKalmanToolTrack::m_chi2Smooth

protected

History of chi2 for each step after smoothing.

Definition at line 169 of file AFPSiDBasicKalmanToolTrack.h.

m_clustersInTrack

std::list<const xAOD::AFPSiHitsCluster*> AFPSiDBasicKalmanToolTrack::m_clustersInTrack

protected

Clusters used to reconstruct the track.

Definition at line 172 of file AFPSiDBasicKalmanToolTrack.h.

m_holes

int AFPSiDBasicKalmanToolTrack::m_holes

protected

Number of layers in which hit from a track is expected, but is not present.

Definition at line 184 of file AFPSiDBasicKalmanToolTrack.h.

m_observationModel

const CLHEP::HepMatrix& AFPSiDBasicKalmanToolTrack::m_observationModel

protected

Observation model, describing transformation from true to measured state.

Definition at line 175 of file AFPSiDBasicKalmanToolTrack.h.

m_observationNoise

const CLHEP::HepMatrix& AFPSiDBasicKalmanToolTrack::m_observationNoise

protected

Matrix representing observation noise disturbing the measurement.

Used to estimate covariance matrix of the track.

Definition at line 180 of file AFPSiDBasicKalmanToolTrack.h.

m_positionAndSlopeCovHistory

std::list< CLHEP::HepMatrix > AFPSiDBasicKalmanToolTrack::m_positionAndSlopeCovHistory

protected

Matrices of updated (a posteriori) estimate covariance of the position and slope for each step \(P_{k|k}\).

Definition at line 147 of file AFPSiDBasicKalmanToolTrack.h.

m_positionAndSlopeCovPredictedHistory

std::list< CLHEP::HepMatrix > AFPSiDBasicKalmanToolTrack::m_positionAndSlopeCovPredictedHistory

protected

Matrices of predicted estimate covariance of the position and slope for each step.

Definition at line 150 of file AFPSiDBasicKalmanToolTrack.h.

m_positionAndSlopeHistory

std::list< CLHEP::HepVector > AFPSiDBasicKalmanToolTrack::m_positionAndSlopeHistory

protected

Vectors of reconstructed true positions for each step \(x_{k}\).

Each 4D vector containing x, y position of the track in a given step as well as slopes in these two directions \(\Delta x, \Delta y\). \(x_{k} = (x, \Delta x, y, \Delta y)\)

Definition at line 137 of file AFPSiDBasicKalmanToolTrack.h.

m_positionAndSlopePredictedHistory

std::list< CLHEP::HepVector > AFPSiDBasicKalmanToolTrack::m_positionAndSlopePredictedHistory

protected

Vectors of predicted true position of a track for each step.

Each 4D vector containing x, y position of the track in a given step as well as slopes in these two directions \(\Delta x, \Delta y\). \(x_{k} = (x, \Delta x, y, \Delta y)\)

Definition at line 144 of file AFPSiDBasicKalmanToolTrack.h.

m_positionAndSlopeSmooth

std::list< CLHEP::HepVector > AFPSiDBasicKalmanToolTrack::m_positionAndSlopeSmooth

protected

Vectors of reconstructed true positions for each step after smoothing \(x_{k}\).

Each 4D vector containing x, y position of the track in a given step as well as slopes in these two directions \(\Delta x, \Delta y\). \(x_{k} = (x, \Delta x, y, \Delta y)\)

Definition at line 163 of file AFPSiDBasicKalmanToolTrack.h.

m_positionAndSlopeSmoothCov

std::list< CLHEP::HepMatrix > AFPSiDBasicKalmanToolTrack::m_positionAndSlopeSmoothCov

protected

Matrices of updated (a posteriori) estimate covariance of the position and slope for each step after smoothing \(P_{k|k}\).

Definition at line 166 of file AFPSiDBasicKalmanToolTrack.h.

m_transitionHistory

std::list< CLHEP::HepMatrix > AFPSiDBasicKalmanToolTrack::m_transitionHistory

protected

Matrices of transitionModel used at each step of track reconstruction.

Definition at line 153 of file AFPSiDBasicKalmanToolTrack.h.

m_zPositionHistory

std::list< float > AFPSiDBasicKalmanToolTrack::m_zPositionHistory

protected

Vectors of reconstructed true positions for each step.

Definition at line 130 of file AFPSiDBasicKalmanToolTrack.h.

---

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

• AFPSiDBasicKalmanToolTrack.h
• AFPSiDBasicKalmanToolTrack.cxx