[^1]

*Abstract*---Standard least-squares curved track fitting process is
tailored for FPGA implementation. The coefficients in the fitting
matrices are carefully chosen so that only shift and accumulation
operations are used in the process. The divisions and full
multiplications are eliminated. Comparison in an application example
shows that the fitting errors of the low resource usage implementation
are less than 4% bigger than the fitting errors of the exact
least-squares algorithm. The implementation is suitable for low-cost,
low-power applications such as high energy physics detector trigger
systems.

*Index Terms*---Trigger, Track Fitting, FPGA Firmware, FPGA Computation

# INTRODUCTION

[IN]{.smallcaps} high-energy physics experiment detectors, track fitting
is normally considered as a software task in the higher level trigger
stage or analysis stage. Although direct porting the fitting algorithm
into today's large size FPGA is not impossible, the cost and power
consumption quickly become concerns without careful resource usage
control. In fact, many silicon area and power consuming operations like
multiplications and divisions in many algorithms can be eliminated or
replaced by low resource usage operations such as shifts, additions and
subtractions. A process deviating from the mathematically accurate one
certainly produces less perfect results. However, significant reduction
in FPGA logic elements and power consumption overweighs small
imperfectness.

In this paper, we describe a curved track fitting functional block
suitable for FPGA implementation. The fitting is based on standard
least-squares algorithm with modifications on the matrix coefficients to
eliminate divisions and full multiplications. The functional block is
designed to match data fetching speed so that it can be used to process
flowing data stream in trigger and DAQ systems.

The FPGA track fitter was developed for the level 1 pixel trigger of the
Fermilab BTeV experiment\[1\]\[2\]. The pixel detector consists of
measurement planes as shown in Fig. 1.

![](media/image1.wmf){width="3.488888888888889in"
height="1.3430555555555554in"}![](media/image2.wmf){width="2.6868055555555554in"
height="1.3319444444444444in"}

The hits on pixel planes are first grouped into track segments in the
FPGA segment tracker using a triplet finding algorithm like Tiny Triplet
Finder (TTF)\[3\]. Then the hits from a track are grouped together,
followed by track fitting, i.e., calculation of the track parameters. In
the original baseline of BTeV trigger system, the track fitting is done
in the trigger CPU farm partially because the hits from full detector
are not switched together until reaching the CPU farm. With our 2004
architecture \[4\], events are built parasitically in the early stages.
Therefore, hits from full detector are available in the FPGA segment
tracker, which makes it possible to perform track fitting in FPGA.

# Principle

## Computations for Track Fitting

The track is projected to both the non-bend and bend views and its
equations can be written approximately:

$\begin{array}{r}
x = x_{0} + l(z - z_{0}) \\
y = y_{0} + h(z - z_{0}) + \eta(z - z_{0})^{2}
\end{array}$ (1)

Either a track has odd or even number of hits, a center of the track is
chosen with *z*=*z*~0~ as shown in Fig. 1. The parameters *x*~0~ and
*y*~0~ are offsets of the track and *l* and *h* are slopes at track
center. The parameter represents the curvature of the track that
represents track momentum. With a set of coordinate measurements *x~i~*
and *y~i~*, the parameters of the tracks can be found with the following
linear combinations.

$\begin{array}{r}
x_{0} = \frac{\sum_{i}^{}{a_{i}x_{i}}}{\sum_{i}^{}a_{i}}\ l = \frac{\sum_{i}^{}{b_{i}x_{i}}}{\sum_{i}^{}{b_{i}(z_{i} - z_{0})}} \\
y_{0} = \frac{\sum_{i}^{}{c_{i}y_{i}}}{\sum_{i}^{}c_{i}}\ h = \frac{\sum_{i}^{}{d_{i}y_{i}}}{\sum_{i}^{}{d_{i}(z_{i} - z_{0})}} \\
\eta = \sum_{i}^{}{e_{i}\frac{y_{i}}{\sum_{i}^{}{e_{i}(z_{i} - z_{0})}}}^{2}
\end{array}$ (2)

The coefficients can be chosen nearly freely as long as the following
constraints are met:

$\sum_{i}^{}{a_{i}(z_{i} - z_{0})} = 0$ (3)

$\sum_{i}^{}b_{i} = 0$ (4)

$\sum_{i}^{}{c_{i}(z_{i} - z_{0})} = 0\ \sum_{i}^{}{c_{i}(z_{i} - z_{0})^{2}} = 0$
(5)

$\sum_{i}^{}d_{i} = 0\ \sum_{i}^{}{d_{i}(z_{i} - z_{0})^{2}} = 0$ (6)

$\sum_{i}^{}e_{i} = 0\ \sum_{i}^{}{e_{i}(z_{i} - z_{0})} = 0$ (7)

Depending on the choice of the coefficients in the linear combination,
the errors of the fitting can be different and the coefficients derived
from the least-squares fitting provide minimum errors for track
reconstruction.

## Non-Division Integer-Only Operations for FPGA

In general, the computations above need floating point multiplications
and divisions. To simplify the computation so that it can be done in
FPGA with low resource usage, the advantage of invariance of Equations
(2) through (7) under re-scaling can be taken. Each set of coefficients
can be multiplied with a common factor so that the sums in the
denominators in Equation (2) become 32, 512 or 4096. The constraints for
the coefficients can be summarized as following:

$\sum_{i}^{}{a\lbrack i\rbrack} = \text{32}\ \sum_{i}^{}{a\lbrack i\rbrack(z_{i} - z_{0}) = 0}$
(8)

$\sum_{i}^{}{b\lbrack i\rbrack(z_{i} - z_{0})} = \text{512}\ \sum_{i}^{}{b\lbrack i\rbrack} = 0$
(9)

$\sum_{i}^{}{c\lbrack i\rbrack} = \text{32}\ \sum_{i}^{}{c\lbrack i\rbrack(z_{i} - z_{0})} = 0\ \sum_{i}^{}{c\lbrack i\rbrack(z_{i} - z_{0})}^{2} = 0$
(10)

$\sum_{i}^{}{d\lbrack i\rbrack(z_{i} - z_{0})} = \text{512}\ \sum_{i}^{}{d\lbrack i\rbrack} = 0\ \sum_{i}^{}{d\lbrack i\rbrack(z_{i} - z_{0})}^{2} = 0$
(11)

$\sum_{i}^{}{e\lbrack i\rbrack(z_{i} - z_{0})^{2}} = \text{4096}\ \sum_{i}^{}{e\lbrack i\rbrack} = 0\ \sum_{i}^{}{e\lbrack i\rbrack(z_{i} - z_{0})} = 0$
(12)

Then the linear combinations for calculating the track parameters can be
rewritten:

$\begin{array}{r}
\text{xx}\text{32} = \sum_{i}^{}{a\lbrack i\rbrack x\lbrack i\rbrack} \approx \text{32}x_{0}\ \text{ll}\text{512} = \sum_{i}^{}{b\lbrack i\rbrack x\lbrack i\rbrack} \approx \text{512}l \\
\text{yy}\text{32} = \sum_{i}^{}{c\lbrack i\rbrack y\lbrack i\rbrack} \approx \text{32}y_{0}\ \text{hh}\text{512} = \sum_{i}^{}{d\lbrack i\rbrack y\lbrack i\rbrack} \approx \text{512}h \\
\text{eta}\text{4096} = \sum_{i}^{}{e\lbrack i\rbrack y\lbrack i\rbrack} \approx \text{4096}\eta
\end{array}$ (13)

The unit of measured coordinates x\[i\] and y\[i\] are chosen so that
they are integers. For example, the channel number in the silicon pixel
detector can be used as the hit coordinates. The coefficients in the
linear combinations are also chosen to be integers and the results of
the linear combinations: xx32, ll512, yy32, hh512 and eta4096 are also
integers, representing the corresponding parameters scaled by factors of
32, 512 and 4096, respectively. Note that divisions are not needed
anymore. The only computations needed in Equation (8) are integer
multiplications and accumulation.

The unit in *z* direction is chosen so that the separation between two
detector planes is 2. In this unit, the possible values of (*z~i~* -
*z*~0~) are also integers, which are even when the number of hits is odd
with the middle plane being 0 and are odd when the number of hits is
even with the two center detector planes being -1 and +1.

## Eliminating Full Multiplications

To reduce computations further, the coefficients in the linear
combinations are limited to the "weight-two" or "two-bit" integers, e.g.
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, which are 2*^m^*+2*^n^* or
2*^m^*-2*^n^* with positive integers *m* and *n*. An example of choosing
e\[i\] for tracks with odd numbers of hits is shown in Table I.

The columns of *e~i~* in Table I represent coefficients derived from the
least-squares fitting. The e\[i\] coefficients are chosen in a spread
sheet, guided by the *e~i~* coefficients. Since the parameterization of
the track in Equation (1) is chosen with symmetry around *z*~0~, the
coefficients for the least-squares fitting are also symmetric. Some
symmetric properties are sufficient conditions for certain constraints
in Equations (8) though (12). For example, the symmetric property *e~i~*
= *e~-i~* exists and it is a sufficient condition for the constraint
*e~i~*(*z~i~*-*z*~0~)=0 making it satisfied automatically. Appropriate
symmetries are programmed in the spread sheet cells so that the
constraints and scaling requirement are satisfied with minimum hand
editing. In our work, the coefficient selection is semi-automatic,
partially for purpose of our own better understanding to the problem.
Clearly it is not too difficult to write a program that chooses the
coefficients automatically.

The relative errors contributed by the parameter for both algorithms are
calculated. The error here is defined as transverse reconstruction RMS
error after projecting the track by half-length (*L*/2) from first or
last hit of the track, with unit of the RMS error for the y\[i\]
measurements. Assume the errors of y\[i\] measurements *y~i~* are
independent and they have a same RMS value *y*, then the error of
calculating parameter can be estimated:

$\text{δη} = \delta y\frac{\sqrt{\sum_{i}^{}{(e\lbrack i\rbrack)^{2}}}}{\text{4096}}$
(14)

The assumption of independence of the measurement errors may be violated
if most tracks are high momentum and parallel but it is a good
approximation for typical detector configuration. The transverse
reconstruction RMS error *Y* after projecting the track by half-length
from first or last hit of the track, i.e., (*z*-*z*~0~) = 2(*L*/2), can
be calculated:

$\delta Y = (z - z_{0})^{2}\text{δη} = 4(\frac{L}{2})^{2}\delta y\frac{\sqrt{\sum_{i}^{}{(e\lbrack i\rbrack)^{2}}}}{\text{4096}}$
(15)

Note that the "projecting" here should just be viewed as a rescaling
process to bring the fitting error of a parameter to a convenient unit.
It is an estimate for a single parameter only. If, for example, the
vertex measurement error is needed, the errors for all parameters should
be considered simultaneously since they could be correlated. The
coefficients e\[i\] for tracks with even numbers of hits is shown in
Table II.

The relative errors contributed by the parameter for both algorithms are
also calculated in Table II.

From Tables I and II, it can be seen that the errors increases for
approximate algorithm with the two-bit integer-only coefficients
comparing with the mathematically perfect least-squares algorithm.
However, the imperfectness of coefficients for the FPGA fitting
algorithm increases the track reconstruction errors only slightly (less
than 4%).

# FPGA Implementation

The block diagram of the FPGA performing the track fitting functions is
shown in Fig. 2. The hit coordinates x(i) and y(i) are clocked through
the fitter, one clock cycles per number.

![](media/image3.png){width="2.8715277777777777in"
height="3.8583333333333334in"}

For each parameter, an accumulator is used to calculate the linear
combination. The coordinate data is shifted through a logarithmic
shifter by pre-defined numbers of bits that are stored in the constant
memory. The shifted version of the coordinate is added to or subtracted
from the accumulator.

Each coordinate is shifted and added/subtracted twice that is equivalent
to multiplying the coordinate by a two-bit integer and accumulating for
the linear combination. The operation uses two clock cycles that matches
the number of cycles needed to fetch a pair of coordinates x(i) and
y(i).

For a fitter processing 16-bit coordinates, 630 logic elements can be
accounted for in the register, shifter & accumulator blocks for the 5
parameters. The silicon resource usage of this portion is about 11% of a
\$30 Altera EP1C6 \[5\] device.

# Fitting Errors and Discussions

The coefficients of fitting matrix for the other two parameters of a
curved track yy32 and hh512 are also calculated using similar procedures
as shown in Table III-VI. The coefficients chosen are two-bit integers.
The relative fitting errors contributed by these two parameters are also
calculated. The relative errors contributed by the three parameters with
different track lengths for both least-squares and approximate
algorithms are plotted in Fig. 3.

![](media/image4.wmf){width="3.5180555555555557in"
height="2.2930555555555556in"}

The approximate algorithm used in FPGA increases the fitting errors for
all parameters as expected from mathematic principle. However, the
differences are very small. In other words, the fitting errors are
relatively insensitive to the variations of the coefficients of the
fitting matrix.

It can be seen from Fig. 3 that the relative error contributed by the
curvature parameter is significantly higher than the errors contributed
by the offset and slope parameters. We will focus on the curvature
parameter in our discussion.

In general, fitting of longer tracks yields smaller errors due to two
reasons: longer lever arms and more measurement points. In order to
compare these two effects, relative errors contributed by the curvature
parameter calculated with several fitting schemes are plotted in Fig. 4.

In addition to the least-squares algorithm and the FPGA approximation
shown in Table I and II, two other "3-point" algorithms are also
studied. One of the 3-point schemes calculates eta4096 using hits of the
first three detector planes at the beginning of a track. In this case,
the lever arm is a fix length, despite of extra length provided by
additional planes. This scheme produces largest errors. When the track
is projected over long distances, the errors increase rapidly. The
calculation method of this scheme is the simplest. However, the results
from this scheme is only useful as a coarse estimate of track momentum,
it causes large errors due to short lever arm when the tracks are to be
projected in long distance.

![](media/image5.wmf){width="3.5180555555555557in"
height="2.2930555555555556in"}

The other 3-point scheme calculates the eta4096 using the first, the
middle and the last hits of a track. In this situation, advantage of the
full length of the track is taken. However, the information provided by
the redundant measurements of the other points in the track is not used.
The relative errors when the track is projected over half-length are
nearly a constant.

The full-length 3-point scheme may appear to be simpler in computation
than the FPGA fitting scheme, but actually it is not the case. To
calculate eta4096 using the 3-point scheme, a floating point
multiplication is needed in order to bring results for different track
lengths into a unified scale. In the FPGA fitting scheme, the scale
unification is achieved through choosing the two-bit coefficients.

# Conclusion

A fitting algorithm suitable for FPGA implementation has been discussed.
With integer shifting and accumulating operations, the fitting errors in
the approximate algorithm is only slightly larger than the errors of the
least-squares fitting algorithm.

Multipliers are now available in more and more FPGA devices today and it
seems that eliminating multiplications is not as critical as several
years ago. Intrinsically, however, multiplication is a power and
resource consuming operation. It is still a good practice to reserve
multipliers to the processes in which multiplications absolutely can not
be eliminated, or the substitution of the multiplications causes
significant degrade of the quality of the results.

Generally speaking, more computations yield better quality of the
results. From the 3-point schemes, to the FPGA fitter, to the
least-squares algorithm, the fitting errors reduce as number of total
operations increases. However, after certain point, the quality of the
results does not improve as rapidly as before. It is common that large
amount of computation brings only small improvement in the
mathematically perfect algorithms. So it is possible to find algorithms
with reasonable amount of computations that produce sufficiently good
results, as illustrated in this paper.

# Appendix {#appendix .Reference-Head}

In this section, we first define a matrix called algorithm matrix which
represents a generic fitting algorithm. Then we will show that the
least-squares algorithm is a special case of the generic algorithms and
compare their fitting errors.

Consider fitting *n* measurement points with a set of *m* (*m*\<*n*)
functions using various algorithms:

$y = a_{0}v_{0}(x) + a_{1}v_{1}(x) + a_{2}v_{2}(x) + \cdots + a_{m}v_{m}(x)$
(A1)

In fitting with parabola, e.g., the functions *v*~0~(*x*) *v*~1~(*x*),
*v*~2~(*x*) are chosen to be 1, *x*, *x*^2^. The parameters *a*~0~,
*a*~1~ to *a~m~* are to be evaluated through fitting the measurement
data (*x*~1~*, y*~1~), (*x*~2~*, y*~2~) to (*x~n~, y~n~*). The
x-coordinates here are known and can have any values. We use an *n*-row
by *m*-column matrix *V* = {*v~ij~*} = {*v~j~*(*x~i~*)} to denote the
function values at the corresponding measurement points.

**Definition 1**: The algorithm matrix *g* = {*g~ji~*} is defined to be
an *m*-row by *n*-column left inverse matrix of *V*:

$\text{gV} = I\ \sum_{i = 1}^{n}{g_{\text{ji}}v_{\text{ik}}} = \delta_{\text{jk}}\ j,k = 0,1\text{.}\text{.}\text{.}m$
(A2)

With an algorithm matrix *g*, the values calculated from the following
linear combinations are called a set of fitting parameters under
algorithm *g*:

$A = \text{gY}\ a_{j} = \sum_{i = 1}^{n}{g_{\text{ji}}y_{i}}\ j = 0,1\text{.}\text{.}\text{.}m$
(A3)

With constraints (A2), the parameters calculated in (A3) reduce to the
"true" values if the fitting model (A1) is correct and there are no
measurement errors. In fact, if for a set of parameters *A'* (the "true"
values), the linear equation system *Y*=*VA'* holds on all rows, then
*A* = *gY* = *gVA'* = *IA'* = *A'*.

In general the left inverse *g* of *n* x *m* matrix *V* is not unique.
For each parameter *a~j~*, there are *n* values of *g~ji~* that satisfy
(*m*+1) constraints which permits different values of *g~ji~* to be
chosen. Each set of *g~ji~* values corresponds to a particular fitting
algorithm. It can be shown that the least-squares fitting algorithm is a
special case of the generic algorithms.

We skip detailed deriving process of least-squares fitting and directly
write done the final result:

$A = (V^{T}V)^{- 1}V^{T}Y\ a_{j} = \sum_{k = 0}^{m}{\zeta_{\text{jk}}\sum_{i = 1}^{n}{v_{\text{ik}}y_{i}}}\ \left\{ \zeta_{\text{jk}} \right\} = (V^{T}V)^{- 1}$
(A4)

We use *G* to represent the algorithm matrix of the least-squares
fitting. Comparing with (A3), it can be seen that:

$G = (V^{T}V)^{- 1}V^{T}\ G_{\text{ji}} = \sum_{k = 0}^{m}{\zeta_{\text{jk}}v_{\text{ik}}}$
(A5)

Clearly matrix *G* satisfies the left inverse constraints given in (A2):

$\text{GV} = (V^{T}V)^{- 1}V^{T}V = I$ (A6)

The least-squares algorithm is chosen as a reference. All the other
generic fitting algorithms are viewed as a deviation from the
least-squares algorithm:

$g = G + \Delta g\ g_{\text{ji}} = G_{\text{ji}} + {\Delta g}_{\text{ji}}$
(A7)

It can be seen from (A7) and (A2) that the row space of *g* is
orthogonal to the column space of *V*:

$\Delta\text{gV} = 0\ \sum_{i = 1}^{n}{({\Delta g}_{\text{ji}})v_{\text{ik}}} = 0\ j,k = 0,1\text{.}\text{.}\text{.}m$
(A8)

The equation (A8) is true for the difference of any two algorithms but
we will use *g* to denote only the difference between an arbitrary
algorithm and the least-squares algorithm.

**Theorem 1**: The row space of difference matrix *g* of two algorithms
is orthogonal to the row space of the algorithm matrix *G* of the
least-squares fitting:

$\Delta\text{gG}^{T} = 0$ (A9)

Combining (A5) and (A8) gives (A9). In fact, (A5) describes that the row
space of *G* is in the column space of *V* and according to (A8) the row
space of *g* is orthogonal to any vectors in the column space of *V*
including row vectors of *G*.

In order to visualize Theorem 1 in a picture, consider a linear fitting
with three data points: (*x*~1~, *y*~1~), (*x*~2~, *y*~2~) and (*x*~3~,
*y*~3~). The two columns in matrix *V* can be shown as two vectors in
the R^3^ space: *v*~0~ = (*x*~1~^0^, *x*~2~^0^, *x*~3~^0^)^T^ =
(1,1,1)^T^ and *v*~1~ = (*x*~1~^1^, *x*~2~^1^, *x*~3~^1^)^T^ as shown in
Fig. 5.

![](media/image6.wmf){width="3.1993055555555556in"
height="2.341666666666667in"}

The row vector *g*~1~ of algorithm matrix *g* must satisfy the
constraints *g*~1~*v*~0~=0 which is the equation of plane PA that is
perpendicular to *v*~0~ and passes the origin. The constraint
*g*~1~*v*~1~=1 is the equation of plane PD that is perpendicular to
*v*~1~ and passes point *v*~1~/(*v*~1~^T^*v*~1~)^2^. The vector *g*~1~
can only take values in the intersection of PA and PD. Similarly, *g*~0~
can only take values in the intersection of PB and PC.

The least-squares algorithm corresponds to the choice of *G*~0~ and
*G*~1~ which are co-planar with *v*~0~ and *v*~1~ and have shortest
lengths. For any other algorithms, the algorithm vector *g*~0~ and
*g*~1~ have longer lengths. The differences (*g*~0~-*G*~0~) and
(*g*~1~-*G*~1~) are orthogonal to *G*~0~ and *G*~1~.

Now consider fitting error for each of the parameters *a*~0~, *a*~1~ to
*a~m~*. If the y-measurements are independents and they have a same
standard deviation *y*, the variations of the parameters can be written:

$({\delta a}_{j})^{2} = (\delta y)^{2}\sum_{i = 1}^{n}{(g_{\text{ji}})^{2}}$
(A10)

The square-sum in (A10) is actually the length of the row vector of the
matrix *g*. It contains contributions from the least-squares algorithm
and the additions from the deviation:

$\sum_{i = 1}^{n}{(g_{\text{ji}})^{2}} = \sum_{i = 1}^{n}{(G_{\text{ji}} + {\Delta g}_{\text{ji}})^{2}} = \sum_{i = 1}^{n}G_{\text{ji}^{2}} + \sum_{i = 1}^{n}{2G_{\text{ji}}{\Delta g}_{\text{ji}}} + \sum_{i = 1}^{n}{\Delta g}_{\text{ji}^{2}}$
(A11)

The middle sum term in (A10) vanishes because from (A9), the row spaces
of *g* and *G* are orthogonal. The variations of the fitting parameters
due to measurement errors are simply composed with two parts:

$({\delta a}_{j})^{2} = (\delta y)^{2}\sum_{i = 1}^{n}{(G_{\text{ji}})^{2}} + (\delta y)^{2}\sum_{i = 1}^{n}{({\Delta g}_{\text{ji}})^{2}}$
(A12)

The equation (A12) reflects a fact that the variation of the parameters
is a minimum when the least-squares fitting algorithm is used. Around
this point, the fitting errors are relatively insensitive to the change
of *g~ji~* values allowing the user to choose different *g~ji~* values
to reduce total computations without increasing fitting errors
significantly. If, for example, all *g~ji~* values differ from *G~ji~*
values by 10%, the error of each parameter increases by only about 0.5%
from the minimum value.

The relative fitting errors of the curvature parameter , (i.e., *a*~2~)
with 17 measurement points for various algorithm deviations are shown in
Fig. 6. This is the case given in the columns with half length of the
track =16 in Table I.

![](media/image7.wmf){width="3.5083333333333333in"
height="2.297222222222222in"}

The algorithm deviations are normalized by dividing the algorithm length
of the least-squares fitting, i.e., the horizontal axis in Fig. 6 is
square root of *g~2i~*^2^/*G~2i~*^2^. The fitting errors are also
normalized with the least-squares fitting result given in the first
column of Table I. The 17 independent measurement points construct a
R^17^ space. The 3 constraints that *g~2i~* must satisfy restrict the
algorithm vector on a 14-dimensional hyper-plane. The parameters *g~2i~*
(i.e., the e\[i\] values in second column of Table I) are chosen
randomly deviating from the least-squares fitting algorithm. The
relative fitting errors behave as suggested in (A12).

# References {#references .Reference-Head}

1.  Kulyavtsev et al., BTeV proposal, Fermilab, May 2000, available: {
    http://www-btev.fnal.gov/DocDB/0000/000066/002/index.html}

2.  E.E. Gottschalk, BTeV detached vertex trigger, Nucl. Instrum. Meth.
    A 473 (2001) 167.

3.  J. Wu et al., "The application of tiny triplet finder (TTF) in BTeV
    pixel trigger", IEEE Tans. Nuclear Science, vol. 53, p 671, 2006.

4.  J. Wu et al., "Integrated Upstream Parasitic Event Building
    Architecture for BTeV Level 1 Pixel Trigger System", IEEE Tans.
    Nuclear Science, vol. 53, p 1039, 2006.

5.  Altera Corporation, "Cyclone FPGA Family Data Sheet", (2003)
    available via: {http://www.altera.com/}

[^1]: ^^Manuscript received May 15, 2006. This work was supported in
    part Operated by Universities Research Association Inc. under
    Contract No. DE-AC02-76CH03000 with the United States Department of
    Energy.

    J. Wu, M. Wang, E. Gottschalk and Z. Shi are with Fermi National
    Accelerator Laboratory, Batavia, IL 60510 USA (phone: 630-840-8911;
    fax: 630-840-2950; e-mail: jywu168@ fnal.gov).