As the final step of the full chain of PHOBOS tracking programs, a fast and inexpensive chi^2 fitting alorithm is mandatory. Due to the difficulties to have the analytical formula of ideal trajectory and its covariant matrix, one have to attact the problem by using of MC technique.

Motivation:
The current template is based on two parameters, Mean_X and Mean_Z, from an approxiamation of the trajectory to a circle. The size of  a single template object is about 1.6Kbyte excluding the size of corresponding covariant matrix, which is 2Kbytes. Since we need something like 80,000 templates (1% error on p, 0.2 degree on theta, and for both charge) for a given vertex and for a given particle species, the necessary memory size to do the proper IO operation may reach to 130Mbytes. Bla bla bla ....
There are several ways to reduce the template size:
1) use single parametrization
2) use coarse binning and develope a nice way to interpolate template
3) use a better matrix package (the current one does not profit the symmetry property)

Here I try to use "alpha" as the template parameter. A template means then a vector of 16 components, where 16 is the number of silicon layers. Each component has "alpha" angle of the corresponding layer. I denote,

Template = {alpha_A,alpha_B, ..., alpha_P} = {alpha}

The covariant matrix is simply,

|   var_AA   var_AB   var_AC   ... ... ...   var_AP   |
|   var_BA    var_BB                                                      |
|   var_CA                         .......                                        |
|       ....                                          .....                                 |
|       ....                                                      ...                       |
|   var_PA                                                       var_PP    |

The measurement of template (ideal trajectory) can be simply done by generating a MC track and passing through the detector without any physics effect (i.e., no pixelization, no multiple scattering, but with average energy loss).

Construction of the covariant matrix can be done by generating many tracks (preferably as many as possible)  and calculating the variance of (alpha_i - avg(alpha_i))*(alpha_j-avg(alpha_j)) where i,j are the layer numbers. There are two main problems here.

1) Pixelization: For the front layers, the actual pixel sizes are noramlly larger than  the average MS angle. So the var_ij can not be measured correctly.

2) Missing layers: For the outer layers, if template passes the very edge of a layer, one can not again measure var_ij correctly because of missing hits. For the outer layers, pixelization effects also exist but marginal compared to this effect.

I picked up 4 momentum values ( 133MeV,  237MeV, 421MeV, 749MeV ) and three theta values (32, 47, 62 degree).
 
 

So the flatness of the Prob(chi^2) is not a function of P or theta only, but rather of both. As you see the plot is sometimes flat sometimes not.

% How to decode the following histogram title
%The first index:       8=pi+, 9=pi-
%The second index: theta in degree
%The third index:       momentum in MeV
 
 

Introduction of Template Table & Interpolation.

In order to use template easily and fast, I introduce a 2dimensional table of N_th and N_qp bins. Each table component is actually a pointer to a template object. The current design of template table is

80 rows (in QP -1 to 1) x 40 columns (in theta 0.43 to 1.23) : corresponding to 3200 templates, in 5% error in P, 1 degree in theta.

where TH=theta, QP=Qlog10(P)
(ie: QP=1 means pi- 100MeV, QP=0.5 means pi- 316 MeV, QP=0 means pi- 1GeV,
       likewise, QP=-0.5 for pi+316MeV, QP=-1 for pi+ 100MeV)

This parametrization is adopted because d(QP)=d(Q*log(P)) = Q dP/P!

So what I want to do with this table?
If a template of (theta, P) is asked, then two procedures are done:

1) map the point (TH,QP) on the table, and get nearest 4 templates. For each layer, alpha value of the template is obtained by interpolation of 4 alpha values of neareat 4 templates (assuming linear behavior).

Here is a schematic view,

alpha_01                                    alpha_11
                                                           |
                                                          b2
                                                           |
                          alpha_xy               +
                                                           |
                                                          b1
                                                           |
alpha_00                                     alpha_10
      +---a1----|---a2--- +

alpha_xy = f_a * f_b* [(alpha_11+alpha_00)-(alpha_01+alpha_10) ]
                  + f_a * (alpha_10-alpha_00)
                  + f_b * (alpha_01-alpha_00)
                  + alpha_00

where f_a = a1 / (a1+a2),  f_b= b1/(b1+b2).

I do the above interpolation for each layer. If there exist any missing hit (0 alpha among 4 alphas), I simply set alpha to zero (conservative way).

2) the covariant matrix is taken from the closest template's.
 

FINDABLE acceptance
 

Y axis:
1.0: 100MeV
0.8: 158MeV
0.6: 251MeV
0.4: 398MeV
0.2: 630MeV
0.0: 1GeV

X axis:
0.5: 29degree
0.6: 34degree
0.7: 40degree
0.8: 46degree
0.9: 52degree
1.0: 57degree
1.1: 63degree
1.2: 69degree

Summary

- Template by this simple single  parametrization can work if following two major problems are resolved.
1) pixel effect in fronts layers
2) missing layer

- The size of template is only 160byte (excluding covariant matrix)