Kalman filter

This page is meant to be a brief introduction to Kalman filters with a few simple examples to illustrate the use and implementation of such filters. The goal is to apply the Kalman filter technique to kinematic fitting in MINOS data analysis.

The Kalman filter is a recursive technique of obtaining the solution to a least squares fit. This recursive method has the advantage of computational efficiency. Given N hits, with 2 measurements (x,y) per hit, a traditional least squares fit involves a matrix inversion whose dimensions are 2N x 2N. In addition, the hits to be included in the fit must be known prior to the fit. The Kalman filter approach performs a calculation as each hit is added to the fit. This has the advantage of a much simpler matrix inversion (2 x 2 versus 2N x 2N). In addition, the Kalman filter is able to extrapolate the fit track to the next hit point at which time actual hits may be searched for in some window of the extrapolation. For references on the Kalman filter, see [1] [2] [3] [4] [5] [6].

The basic Kalman filter deals with linear systems (non-linear systems are treated by a linear approximation using the extended Kalman filter, to be discussed later). We use the notation of Fruhwirth [4], and make the following definitions:

• x_k = the filtered state vector at point k
• x_k+1^k = the extrapolated state vector from point k to point k+1
• C_k+1^k = the covariance matrix of x_k+1^k - x_k+1^t, where x_k+1^t is the true value of the state vector at point k+1
• C_k = the filtered covariance matrix at point k
• F_k = the propagator of the state vector from point k to point k+1
• w_k = the process noise (random disturbance) to the state vector at point k
• Q_k = the covariance matrix of w_k
• m_k = the measurement vector at point k
• e_k = the measurement noise at point k
• V_k = the covariance matrix of e_k

The two basic equations are

• x_k = F_k-1 x_k-1 + w_k-1
• m_k = H_k x_k + e_k

Typically, the state vector would be a vector of length 5, with two transverse positions and three momentum as its components. The measurement vector might be of length 3, consisting of one hit scintillator strip, the time of the hit, and the integrated charge. These are merely examples to illustrate the two vector types.

To begin the Kalman filter, the following must first be defined:

• x₀ = an initial estimate of the state vector
• F_k = the state propagator matrices for all points
• Q_k = the process noise covariance matrices for all points
• V_k = the measurement noise covariance matrices for all points
• H_k = the matrices which convert a state vector at point k into a measurement vector

The initial state covariance matrix C₀ can be set to the identity matrix multiplied by a large scale factor. The smaller this is, the more weight is put on the initial state vector, so in general we would like to make C₀ as large as possible. However, because of round-off errors, we need to restrict this matrix to a reasonable value, which depends on the particular fit under consideration.

We are now ready to apply the Kalman filter. At each point k, a four step process is applied:

1. C_k^k-1 = F_k-1 C_k-1 F_k-1^T + Q_k-1
2. K_k = C_k^k-1 H_k^T ( V_k + H_k C_k^k-1 H_k^T )^-1
3. x_k = F_k-1 x_k-1 + K_k ( m_k - H_k F_k-1 x_k-1 )
4. C_k = (1 - K_k H_k) C_k^k-1

I have combined the extrapolation and filtering of the state vector into one step (3). In most references, these two processes are presented separately. At the end of the iterative process, the final state vector x_k represents the fit values using all data points. To obtain the fit values at any point k, the user can then fit backwards, starting with the last point. The fit value at some point k is then the average between the state vectors x_k between the two fits.

I have written some code in C++ to help me understand the Kalman filter. This code uses the TMatrix and TVector classes from ROOT, so to compile and run this code, one needs the ROOT libraries on their system.

Example: Average
The first program presented here takes the weighted average of a set of values. In this example, state and measurement vectors have length 1. Vectors and matrices are then equivalent to scalars. The measurements m_k I set to the input data points to be averaged. I initialize the matrix (scalar) V_k to the variances (squares of the errors). Because the state vector is the measurement vector, the matrix H_k becomes unity, as does the propagator matrix F_k. There is no process noise, so Q_k vanishes.

The Kalman filter applied to a weighted average.

The black points represent the measured data; the blue points represents the filtered state vector as calculated by the Kalman filter at point k. The uncertainty on the filtered state vector is obtained from the covariance matrix C_k and is seen to grow smaller with increasing k, as expected. The final value of the Kalman fit is 4.24835+-0.20320, whereas the true value from a least squares calculation (shown as a horizontal red line in the plot) is 4.24838+-0.20320, a fractional agreement in the weighted average of 10^-5.

The main program is in average.cc. The Kalman class is defined in kalman.h and is the heart of the Kalman filtering routine. Other header files needed to compile and run this example are misc.h, definitions.h, and simplearray.h.

Example: Charged particle in a dipole field
In this example, several x,y coordinates are measured in regions of no magnetic field at fixed z positions both upstream and downstream of a dipole magnet (with primary component transverse to the beam axis). A total of 20 tracking stations with a uniform spacing of 1 meter is simulated; each tracking station provides a measurement of both transverse position with a resolution of 5 mm in each coordinate. Each tracking station represents a radiation length of 1%. No energy loss is simulated. The magnetic field is located after the 10th tracking station and before the 11th. There is only one component, the magnitude of which is a Gaussian function of the longitudinal position, with a maximum value of 5 Tesla and a spatial RMS of 0.1 meter, representing a momentum kick of 0.376 GeV/c. We choose our state vector to be of dimension 5, representing the two transverse positions, the transverse slopes, and the charge to momentum ratio. At every iteration of the filter except for the one which traverses the magnetic field, the equations of motion are linear. The only complication involves multiple scattering, which is taken into account through the process noise covariance matrix. We use the calculation of Wolin and Ho [5]. The propagation of the state vector between the 10th and 11th planes is almost linear, but not quite. We linearize the system by calculating first derivatives of the state vector with respect to itself. In the Kalman filter, the propagation is done not by taking the product of the propagator matrix with the state vector, but rather by swimming the state vector through the magnetic field. The linearized propagator matrix is used in calculating the state covariance matrix and the Kalman gain matrix.

The Kalman filter applied to charged particle in a dipole field. The momentum distribution is plotted in (a). The difference between the fit and true momenta divided by the true momentum is shown in (b). The mean value of the fit momentum ratio is shown as a function of momentum in (c). The square of the RMS of the fit momentum ratio is shown as a function of momentum squared in (d).

The magnetic field represents a simple p_T kick in the x direction:

• p theta = p^x₂ - p^x₁ = p_T

• e_dp/p² = (p² / p_T²) e_theta²

• e_theta = e_x / L [12 / (N (N² - 1))]^1/2

• e_theta = [0.0136 / p] (x/x₀)^1/2 [1 + .038 log(x/x₀)]

• e_dp/p² = 0.34e-4 + .43e-5 p²

Last modified: 21 April 1999
Roy Lee