Documentation for the 'Find_Jpsi_Ks' software that searches
tracks and track pairs using the Fiber Tracker
------------------------------------------------------


Bruce Hoeneisen
1 March 2001

Abstract
--------
We describe the 'Find_Jpsi_Ks' software that searches tracks
and track pairs using the Fiber Tracker. To obtain high
efficiency, low minimum pT and maximum eta reach, the only
hard-wired requirements on the track are hits on axial and
stereo layers 2, 3, 4 and 5, plus one hit in layer 1A or 6A.
Other requirements are set by RCP parameters. The software
has been tested with pT as low as 0.1GeV/c and fiber
ocupancy as high as 12%. The software is particularly
suited for B ---> J/psi Ks ---> l+ l- pi+ pi- in L3,
RECO and offline.


Contents
--------
1. For the impatient
2. Intruduction
3. Theoretical performance
4. Coordinate system
5. List of objects
6. List of functions
7. Usage
8. Measured performance
9. Recommended RCP parameters
10. Conclusions


1. For the impatient

Copy everything from '~bruce1/Find_Jpsi_Ks/release1/' on 'd0mino.fnal.gov'
to your directory. Enter 'setup kai'. Enter 'source ./Makefile' to
compile and link. Enter './Find_Jpsi_Ks' to run. You will see the
output on your screen. (If you do not have the 'kai' compiler, edit
'Makefile' and select your compiler.)

The driver function 'Main.cpp' was written to test the software in
stand-alone mode. 'Main.cpp' reads fiber tracker cluster hits from
'Hits_test.dat' and adds noise hits for test purposes. Then 'Main.cpp'
calls the following independent functions for each event:

'find_tracks_xy' which returns a list of found tracks in the transverse plane;
'find_tracks_xyz' which returns a list of found tracks in 3-dimensions;
'find_track_pairs' which returns a list of pairs of tracks that originate
   from a common point;
'get_errors' which fits the track pairs and obtains parameters of the
   daughter tracks and parent particle with their errors.

Each of these independent functions is in its own class, e.g.
'Find_Tracks_xy'. Before the first call of one of these functions,
i.e. during the run setup, it is necessary to call 'read_RCP' to
load the RCP parameters. Four sets of RCP files are provided optimized
for Jpsi's, Ks's, high pT tracks, and for test purposes, and can be
chosen in 'Main.cpp'. The names of these files are self-explanatory,
e.g. "Find_Tracks_xy_Jpsi.RCP". The usage of the software is detailed
in 'Main.cpp'.

To test the software in stand-alone mode choose the desired fiber
ocupancy and RCP files in 'Main.cpp'.

*********************************************************************
A PLEA FOR HELP! We need to get this software officially released.
I have carried it as far as I can, and will maintain it throughout
the run. However the following is needed: a)Someone who understands
the fiber tracker software to write a function that fills my
'Hits' object with the fiber tracker hit clusters (after resolution
of hits by neighboring fibers; see Section 4 below, 'Hits.hpp',
'Hits_test.dat' and 'Main.cpp' for format and usage). b) Replace
my stand-alone RCP parameter reading scheme with the standard D0
functions. As far as I know, the rest of the code conforms to D0
recommendations. This is only a litle bit of work for someone familiar
with the misteries of the fiber tracker and D0 code.
A VOLUNTEER IS NEEDED!
*********************************************************************

2. Introduction

The main aplication in mind for this software is the measurement
of sin(2*beta) using the golden channel

B^0 ---> J/psi Ks ---> l+ l- pi+ pi-                            (1)

We must be able to reconstruct track PAIRS with very low transverse
momenta, without constraining the tracks to originate near
(x, y) = (0, 0) and without using z information. The tracks may have
such low pT that they do not even exit the fiber tracker. Our
emphasis is on high efficiency finding of track PAIRS in a noisy
environment.

The strategy is as follows. For events triggered on two A-layer muons,
or events triggered on two electromagnetic clusters,
search for J/psi in trigger level L3
(there is no need to run 'get_errors' at this stage). Then, for these
events, search for J/psi and Ks in RECO and put this information on
both the DST's and the Tumbnail. Otherwise the measurement of sin(2*beta)
will not be feasible with available CPU resources.

An additional use of the 'Find_Jpsi_Ks' software is the search for

Lambda_b ---> J/psi Lambda^0 ---> l+ l- p+ pi-.                 (2)

The software is also usefull for general tracking of low or high
pT particles, and for efficiency studies of other tracking algorithms.

The kinematics of (1) and (2) is documented in detail in D0 note
1984. The differential cross section
of Ks's from B's drops by a decade from p_T = 2GeV/c to 8GeV/c. The
differential cross section of pions from Ks's from B's drops by a
decade from 0GeV/c to 3.5GeV/c, and by another decade from 3.5GeV/c to
7GeV/c. Interesting cuts can be applied to DR, the distance between
the J/psi and the Ks in (eta, phi) space, but we do not consider
them here (see D0 note 1984).

Why write yet another algorithm to reconstruct tracks in the
fiber tracker? Finding tracks is different from finding track PAIRS:
if a track requires, say, 16 hits, then a track pair needs only about 9
hits per track (to have the same number of fakes with a given
fiber noise occupancy). Therefore the pattern recognition algorithm can
be quite different. For example we require hits only on axial and
stereo layers 2, 3, 4 and 5, thereby: a) Extending the pseudo-rapidity
reach of the tracker; b) Extending the transverse impact parameter that
can be reconstructed; c) Finding tracks of very low transverse
momentum that do not exit the fiber tracker; and d) Increasing the
efficiency.

The following sections of this documentation explain the
theoretical performance of this algorithm, the coordinate system
and track model, the list of objects, list of functions,
the measured performance, and usage.


3. Theoretical performance

  The number of fake tracks found in the transverse (x, y) plane is
of order

n_xy = 3*10^6*e^n*Bmag[T]/pTmin[GeV/c]

where e is the fiber occupancy, Bmag is the magnetic field, and pTmin
is the minimum transverse momentum of the searched tracks. The
number of required axial doublet layers is n. The calculation of n_xy
is presented in Appendix A, and asumes pTmin > 0.1GeV/c.

  For EACH fake track found in the transverse plane (x, y) there are n_z
fake tracks found in three dimensions, where approximately

n_z = 2*10^4*e^n

(see Appendix A). Here n is the number of required stereo doublet layers.

  The number of fake found track PAIRS (before any invariant mass or
opposite sign or impact parameter cuts) is then of order

n_fake = 2*10^19*e^(4n)*(Bmag[T]/pTmin[GeV/c]^2)

asuming that we require hits in n axial layers and n stereo layers.

  To understand the preceeding equation, let us consider the case
Bmag = 2T and pTmin = 0.1GeV/c. Then we obtain n_fake = 1 for the
ocupancies listed in the following Table. The corresponding values
of n_xy and n_z are also listed. The fiber tracker is usefull
for ocupancies less than the ones indicated in the Table 1.

Table 1.
----------------------------------------------------------------------
number of layers   maximum useful fiber ocupancy   at maximum ocupancy
       n                       e                   n_xy      n_xy*n_z
----------------------------------------------------------------------
       4                       4.2%                200          13
       5                       8.0%                200          13
       6                      12.2%                200          13
       7                      16.5%                200          13
       8                      20.7%                200          13
----------------------------------------------------------------------

Note that the performance depends on the setting of the RCP parameters
and the numbers presented in this section are only order of magnitude
estimates. The actual performance is lower due to correlations: real
tracks pick up "noise" hits. The MEASURED performance is discussed in
Sections 8 and 9.

We require hits in 4 axial layers (5A, 4A, 3A, 2A) and the corresponding
4 stereo layers (5U, 4V, 3U, 2V). We require at least one hit in axial
layers 1A or 6A. These are the only hard-wired requirements. All other
requirements are set by RCP parameters. For example, 'minHitsA',
'minHitsS' and 'minHits' determine the required number of axial, stereo
and total hits.


4. Coordinate system

The axis of the Fiber Tracker is z. The transverse plane is (x, y).
Phi is the polar angle measured from the x axis counter-clockwise
and is in the range 0 <= phi < 2*pi.
There are 16 Fiber Tracker layers numbered from n = 0 to 15 in this
order (A stands for 'axial' and 'U' and 'V' are the stereo layers):
1A, 1U, 2A, 2V, 3A, 3U, 4A, 4V, 5A, 5U, 6A, 6V, 7A, 7U, 8A, 8V.
The bins (or clusters) in layer n are numbered from i = 0 to max(n) - 1
counter-clockwise starting at phi = 0. The radius of layer n is r(n).
The numerical values of max(n) and r(n) are given in 'Find_Tracks_xy.cpp'.
For an axial layer n:

x = r(n)*cos(phi)
y = r(n)*sin(phi)

where

phi = 2*pi*i/max(n).

(i is the i'th bin (or cluster) in layer n).

For a stereo fiber in layer n (with cluster i):

x = r(n)*cos(phi)
y = r(n)*sin(phi)
phi + m*2*pi = a + b*z

with a = 2*pi*i/max(n) and b = tan(3deg)/r(n), and m = 0 or 1 or -1.
For z = 0, m = 0. m is used to keep phi in the range 0 <= phi < 2*pi.

A track is defined by one set of hits in axial and stereo layers 2, 3, 4
and 5 (all required), and hits in layers 1, 6, 7 and 8 (which are
searched and may be optionally required depending on RCP parameters).
Note that we consider only a single pass through the layers.

The pattern-recognition algorithm asumes constant magnetic field over three
adjacent layers, which is a reasonable approximation near the center
of the D0 detector Solenoid. The helical tracks are then modeled as follows:

x = x0 + R*cos(alpha)
y = y0 + R*sin(alpha)

where

alpha = A + B*z.

We define the azimuth angle alpha of the helical track on layer 5A,
alpha_5, to be in the range 0 <= alpha_5 < 2*pi. For other layers
alpha is defined to be continuous (i.e. no jumps by 2*pi).

If B >= 9.0e6, then the track is in the transverse plane. In
this case we define A = z.

The magnetic field Bmag is positive if it is in the +z direction.


5. List of objects

For details see the corresponding '*.hpp' files.

'Hits': Contains a list of hit Fiber Tracker clusters of one
  event (neighboring hits have already been resolved into clusters).

'TrackFound_xy': List of clusters of one found track in xy.

'LTrackFound_xy': List of found tracks in xy.

'TrackFound_xyz': List of clusters of one found track in xyz.

'LTrackFound_xyz': List of found tracks in xyz.

'DecayPair': Pair of tracks that originate from a common vertex.

'LDecayPair': List of DecayPair's.


6. List of functions

There are four INDEPENDENT functions, each in its own class.
For details see the corresponding '*.hpp' and '*.cpp' files.

'Find_Track_xy::find_track_xy':

This function has a 'Hits' object as input and a 'LTrackFound_xy'
object as output.

The search begins with a scan of clusters in layer 5A.
For each cluster in layer 5A search '2*nbins_search' fiber bins in
layer 4A. For each hit bin found in layer 4A search '2*nbins_pT' fiber
bins in layer 3A. The search width 'nbins_pT' is determined by 'pTmin'
and 'Bmag'. For each hit bin found in layer 3A search
bins in layer 2A around the bin corresponding to the circular track defined by
the hits in layers 3A, 4A and 5A. The width of the search on layer 2A
is determined by 'dlmin' plus 'mcs' standard deviations of the Multiple Coulomb
Scattering. 'nbins_search', 'pTmin', 'Bmag', 'dlmin' and 'mcs' are RCP parameters.

We require that the distance of the circle to the point (0, 0) be
within the range from 'dmin' to 'dmax'. Thus we can require the
tracks to originate near, or far from, (0, 0) by setting
the RCP parameters 'dmin' and 'dmax' as needed.

Then we search optional hits in layers 1A and 6A, 7A and 8A. We
require at least one hit on layers 1A or 6A to reduce the number of
found xy tracks. If no hit is found in layers 6A and 7A the search on
layer 8A is abandoned.

Note that hits in layers 5A, 4A, 3A, and 2A are required. At least one
hit is required in 1A or 6A. The minimum number of axial
hits is 5 <= 'minHitsA' <=8.


'Find_Track_xyz::find_track_xyz'

This function has a 'LTrackFound_xy' object and a 'Hits' object as input and
a 'LTrackFound_xyz' object as output. For each found track in xy we loop
over stereo fibers in layers 5U and 2V. These pairs define helical tracks.
The helical tracks permit prediction of z's on layers 4V and 3U. Then
we loop over hits in 4V and 3U to search for matches to within 'dzmin'.
Stereo hits are required on layers 2V, 3U, 4V and 5U. Finally additional
stereo hits are searched in layers 1U, 6V, 7U, 8V. These hits are optional.
The minimum number of required stereo hits is 4 <= minHitsS <= 8, and
the required number of total hits (axial and stereo) is
9 <= 'minHits' <= 16.


'Find_Track_Pairs::find_track_pairs'

This function has a 'LTrackFound_xyz' object as input and a 'LDecayPair'
as output. We loop over pairs of tracks found in xyz. A track pair is
obtained by finding the intersection (x, y) in the transverse plane
closest to (0, 0). Then for each track we obtain the z of the
intersection (x, y). If these two z's differ by less than
the RCP parameter 'dzmin' we have a pair of tracks with a common origin
(x, y, z). We require that the two tracks have opposite charge
if the RCP parameter 'oposite_charge' is set to 1.
Then we require that the transverse impact parameter,
sqrt(x^2 + y^2), be in the range from 'bmin' to 'bmax' (which are RCP
parameters). Also we require that the invariant mass of the track
pair be in the range from 'mmin' to 'mmax'. We have not imposed the
condition that the parent come from the direction of (0, 0), and
leave this additional constraint to the user.

We note that most of the "fake" tracks are really not fake: they are
real tracks that have picked up one or two noise hits. For this
reason we run the functions 'clean_tracks_xy', 'clean_tracks_xyz' and
'clean_pair' if the corresponding RCP parameters 'clean_LTrackFound_xy',
'clean_LTrackFound_xyz' and 'clean_LDecayPair' are set to 1.


'Get_Errors::get_errors'

This function has a 'LDecayPair' object as input and another 'LDecayPair' as
output. The output has the same information as the input, and additionally
has the fitted parameters of the 'DecayPair's and their errors. To obtain
the errors we recalculate the parameters asuming that the hits are shifted
by + or - one bin.


7. Usage

The usage is detailed in the file 'Main.cpp'. The usage of the function
'find_tracks_xy' is as follows:

  ///////////////////////////////////////////////////////////////////////////
  //Given fiber tracker hit clusters, find xy tracks:

  Find_Tracks_xy fxy; //Once at begining of run.

  LTrackFound_xy ltfxy; //Once at begining of run.

  //Read RCP once at begining of run.
  bool xyRCP;
  xyRCP = fxy.read_RCP("Find_Tracks_xy_test.RCP"); //Chose the RCP file.
//  xyRCP = fxy.read_RCP("Find_Tracks_xy_Ks.RCP");
//  xyRCP = fxy.read_RCP("Find_Tracks_xy_Jpsi.RCP");
//  xyRCP = fxy.read_RCP("Find_Tracks_xy_highpT.RCP");
  if(!xyRCP)
  {
    cout << "Main: Error: Could not read the RCP file.\n";
    return 0;
  };

  //Given hits find tracks in xy:
  fxy.find_tracks_xy(Hits_test, ltfxy, Bmag); //Find xy tracks. Once per event.
  if(ltfxy.error != 0)
  {
    cout << "Main: error = "
      << ltfxy.error << " from 'Find_Tracks_xy'.\n";
    return 0;
  };
  ////////////////////////////////////////////////////////////////////////

Note that we provide four sets of RCP parameters that have been optimized for
Ks, J/psi, high pT physics, or for test purposes. The usage of the functions
'find_tracks_xyz', 'find_track_pairs' and 'get_errors' is similar, see
'Main.cpp' for details.


8. Measured performance

The following measurements were made with the RCP parameters:
nbins_search = 200, pTmin = 0.1GeV/c, mcs = 2.0, dlmin = 0.25mm,
dzmin = 7.0mm, minHitsA = 5, minHits = 9, bmin = 10mm,
bmax = 240mm, clean_LTrackFound_xy = 1, clean_LTrackFound_xyz = 1
clean_LDecayPair = 1. Note the very low threshold pTmin which
is challenging. The number of real xy tracks in the test was 4,
the number of real xyz tracks was 4, and the number of real track
pairs was 2. Random hits are added to obtain the occupancies
listed below. Note that the occupancy e is the fraction of
hit fibers. We take the fraction of hit clusters to be
e/3 (since one fiber of a doublet corresponds to two clusters
and one noise track hits 1.5 fibers on average but only one
cluster). No invariant mass cut or opposite sign cut is applied
in this test. These are our "loose" cuts. The number of fakes obtained
as a function of fiber occupancy is listed in Table 2.

Table 2. Fakes for "loose" cuts.
-----------------------------------------------------------
occupancy   fake xy tracks   fake xyz tracks   fake track
e           n_xy             n_xy*n_z          pairs
-----------------------------------------------------------
0.00                0               0               0
0.03                0               0               0
0.04                8               0               0
0.05               33               3               3
-----------------------------------------------------------

"Standard" cuts are the same as "loose" cuts, but
minHitsA = 6, and minHits = 12. See Table 3.

Table 3. Fakes for "standard" cuts.
-----------------------------------------------------------
occupancy   fake xy tracks   fake xyz tracks   fake track
e           n_xy             n_xy*n_z          pairs
-----------------------------------------------------------
0.00                0               0               0
0.03                0               0               0
0.04                8               0               0
0.05               33               0               0
0.06               number of xy tracks overflowes
-----------------------------------------------------------

Finally consider "tight" cuts, which are the same as "loose" cuts
but with nbins_search = 150 and pTmin = 0.3GeV/c and minHitsA = 7
and minHits = 14. The results are shown in Table 4.

Table 3. Fakes for "tight" cuts.
-----------------------------------------------------------
occupancy   fake xy tracks   fake xyz tracks   fake track
e           n_xy             n_xy*n_z          pairs
-----------------------------------------------------------
0.00                0               0               0
0.04                0               0               0
0.05                2               0               0
0.06                4               1               0
0.07                8               1               0
0.08               10               1               0
0.09               19               2               0
0.10               28               2               0
0.11     more than limit of 200 xy tracks after scanning 7A
-----------------------------------------------------------

Note that the algorithm is VERY robust.


9. Recommended RCP parameters.

In this Section we show suggested initial RCP parameters for
J/psi, Ks and high pT physics, and the corresponding performance.
Note that we seek high efficiency and large eta coverage so
we require only 6 axial hits and 6 stereo hits per track (i.e. we
do not require the tracks to traverse layers 7 and 8). Note
also our very low pT thresholds. Finally recall that we have
no z-constraint. We require that track pairs have opposite sign.
The RCP parameter files and the fiber occupancy can be chosen
in 'Main.cpp'.


9.1 J/psi

Performance at the extreem fiber occupancy of 12%, or cluster
occupancy of 4%.

From 'Find_Tracks_xy_Jpsi.RCP':
   nbins_search = 36, pTmin = 0.5, mcs = 2.5   dlmin = 0.25,
   minHitsA = 6,
   dmin = -1, dmax = 10.
   clean_LTrackFound_xy = 1,
   verbose = 5.
Performance: Find 12 xy tracks after scanning 1A through 6A,
11 xy tracks after scanning 7A and 8A, and 11 clean tracks including
the 2 of interest.

From 'Find_Tracks_xyz_Jpsi.RCP':
   dzmin = 7,
   minHitsA = 6, minHitsS = 6, minHits = 12,
   clean_LTrackFound_xyz = 1,
   verbose = 5.
Performance: Found 13 xyz tracks, and 11 clean xyz tracks including the
2 of interest.

From 'Find_Track_Pairs_Jpsi.RCP':
   dzmin = 20,
   minHits = 12,
   bmin = -10, bmax = 10,
   opposite_charge = 1,
   mmin = 2.6, mmax = 3.6,
   clean_LDecayPair = 1,
   verbose = 5.
Performance: Found 6 track pairs from common vertex, and 2 clean track
pairs: the correct pair and one fake.


9.2 Ks

Performance at 6% fiber occupancy or 3% cluster occupancy (at higher
occupancy the found xy tracks exceed the limit of 200 at our very low
pT threshold).

From 'Find_Tracks_xy_Ks.RCP':
   nbins_search = 150, pTmin = 0.2, mcs = 2.5   dlmin = 0.25,
   minHitsA = 6,
   dmin = 3, dmax = 300.
   clean_LTrackFound_xy = 1,
   verbose = 5.
Performance: Find 153 xy tracks after scanning 1A through 6A, 147
xy tracks after scanning 7A and 8A, 121 clean xy tracks including the
2 of interest.

From 'Find_Tracks_xyz_Ks.RCP':
   dzmin = 7,
   minHitsA = 6, minHitsS = 6, minHits = 12,
   clean_LTrackFound_xyz = 1,
   verbose = 5.
Performance: Found 14 xyz tracks, and 10 clean xyz tracks including
the 2 of interest.

From 'Find_Track_Pairs_Ks.RCP':
   dzmin = 20,
   minHits = 12,
   bmin = 10, bmax = 240,
   opposite_charge = 1,
   mmin = 0.2, mmax = 0.8,
   clean_LDecayPair = 1,
   verbose = 5.
Performance: Found 2 track pairs originating from common vertex, and
1 clean track pair with precisely the correct two tracks.

Note that we obtain no fake track PAIRS even tho there are many
fake xy and xyz tracks.


9.3 High pT physics

Performance at the extreem fiber occupancy of 12%, or cluster
occupancy of 4%.

From 'Find_Tracks_xy_highpT.RCP':
   nbins_search = 9, pTmin = 2, mcs = 3   dlmin = 0.33,
   minHitsA = 6,
   dmin = -1, dmax = 240.
   clean_LTrackFound_xy = 1,
   verbose = 5.
Performance: Found 4 xy tracks after scanning 1A through 6A, 3 tracks
after scanning 7A and 8A, and 3 clean tracks, including the correct one.

From 'Find_Tracks_xyz_highpT.RCP':
   dzmin = 7,
   minHitsA = 6, minHitsS = 6, minHits = 12,
   clean_LTrackFound_xyz = 1,
   verbose = 5.
Performance: Found 3 xyz tracks, and 2 clean xyz tracks, the
correct one and one fake. Note the low number of fakes even
at 12% ocupancy and high efficiency (only 6 axial and 6 stereo hits
per track).


10. Conclusions.

We have developed an algorithm to efficiently find tracks and
PAIRS of tracks with very low momenta in a high noise
environment using only the fiber tracker. The principal
application is B-physics, particularly the channel
B^0 ---> J/psi Ks. We provide independent
functions 'find_tracks_xy', 'find_tracks_xyz',
'find_track_pairs' and 'get_errors'. These functions
will find applications in the L3 filter, in RECO and
in off-line analysis. The software can also be used to
find single tracks, and for efficiency studies
of other algorithms. The algorithm has been tested
with pT as low as 0.1GeV/c and fiber ocupancies as
high as 12%


Appendix A: Fake tracks

The search for tracks in the transverse (x, y) plane begins with a scan of
layer 5A. The doublet layer 5A has 2*2560 fibers and 2*2560*e hit fibers,
where e is the fiber occupancy. The number of cluster bins is 4*2560 and
the number of hit clusters is 2*2560*e/1.5, since on average a "noise" track
hits 1.5 fibers of the doublet. The ocupancy of the cluster bins is
therefore e/3.

Then we search approximately 400 cluster bins in layer 4A (determined by an RCP
parameter). These bins contain 400*e/3 hits.
Then we search approximately
20*Bmag/pTmin bins in layer 3A, where Bmag is the mangetic induction in
Tesla, and pTmin is the minimum transverse momentum in GeV/c.
The search continues over approximately three bins in each succeeding axial
layer. This gives an estimate of the number
of fake found tracks in the (x, y) plane given by n_xy in Section 3.

The stereo angle is 3 degrees, the fiber pitch is 0.97mm, and the fiber
length of layer 5A is 2520mm. So one fiber in layer 5A is crossed by
136 fibers in layer 5U. Similarly, one fiber in layer 2A is crossed by
90 fibers in layer 2V. So, for each track found in the transverse plane,
we search 4*136*e/3 hits in the doublet layer 5U, and 4*90*e/3 hits in
doublet layer 2V. Then we have to search approximately three cluster bins
in each additional stereo layer. This gives the number of fake tracks found
in (x, y, z) for each track found in (x, y) as given by n_z in Section 3.

So the number of fake track pairs is 0.5*((n_xy*n_z)^2). The probability that
two fake tracks cross at the same z is about 1/90. The
result is an estimate of the number of fake pairs, n_fake, and is given in
Section 3.


Appendix B: Random calculations

1.- Nuclear collision length of pions in nylon: 51cm.

2.- dE/dx of charged pions in nylon: 2.25MeV/cm at p = 0.42GeV/c;
4.5MeV/cm at p = 0.1GeV/c; 11MeV/cm at p = 0.05MeV/c,
2.9MeV/cm at p = 10GeV/c. So a pion with momentum 0.1GeV/c will
loose half of its momentum in about 7cm of nylon. The 8 layers
of the fiber tracker are equivalent to about 4cm of nylon (?).
Conclusion: dE/dx becomes important for pT < 0.1GeV/c
For such low pT particles we can not simply asume circular tracks
in the transverse plane. This is why we approximate
to circles only for 3 or 4 neighboring layers. dE/dx given by pulse
hights might help particle identification for very low
momentum pions.

3.- Multiple Coulomb Scattering. Standard deviation of angle in plane for
pions through 4mm of nylon = theta. x/Xo = 4mm/367mm.

Theta = (0.0012GeV/c)/(beta*p) [radians].

At what momentum is theta = 1mm/50mm = 0.02? Answer: p = 0.1GeV/c.
At much higher momentum we can neglect Multiple Coulomb Scattering
compared to the Fiber Tracker position resolution. For lower momentum,
Multiple Coulomb Scattering dominates the resolution.

4.- A Ks decays into a pi+ with momentum p_pi = 0.206GeV/c in the direction +y,
and a pi- with momentum p_pi = 0.206GeV/c in the direction -y, in the Ks rest
frame. Now boost the Ks in the x direction until its momentum in the lab
frame is p_K. What is the opening angle alpha of the two pions? Answer:

tan(alpha/2) = p_pi*m_K/(p_K*sqrt(m_pi^2 + p_pi^2)).

For p_K = 1GeV/c, alpha = 0.41 radians. For p_K = 3GeV/c, alpha = 0.14 radians.

5.- What is the radius of a pion track in the transverse plane if pT = 0.1GeV/c?
Answer: 167mm for Bmag = 2T.