Added class to read reconstruction parameters from OCDB (Yuri)
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALTrack.cxx
1 //========================================================================
2 // Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. 
3 //                                                                        
4 // Author: The ALICE Off-line Project.                                    
5 // Contributors are mentioned in the code where appropriate.              
6 //                                                                        
7 // Permission to use, copy, modify and distribute this software and its   
8 // documentation strictly for non-commercial purposes is hereby granted   
9 // without fee, provided that the above copyright notice appears in all   
10 // copies and that both the copyright notice and this permission notice   
11 // appear in the supporting documentation. The authors make no claims     
12 // about the suitability of this software for any purpose. It is          
13 // provided "as is" without express or implied warranty.                  
14 //========================================================================  
15 //                       
16 //                       Class AliEMCALTrack 
17 //                      ---------------------
18 //    A class implementing a track which is propagated to EMCAL and 
19 //    matches and EMCAL cluster. 
20 //    This track object will not update Kalman parameters, but it 
21 //    allows for track propagation and suitable energy loss correction,
22 //    even in an environment with a variable magnetic field, which is not
23 //    well managed in the AliExternalTrackParam class.
24 // ------------------------------------------------------------------------
25 // author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
26 //=========================================================================
27
28 #include "Riostream.h"
29
30 #include "TVector3.h"
31
32 #include "AliLog.h"
33 #include "AliTracker.h"
34 #include "AliESDtrack.h" 
35
36 #include "AliEMCALTrack.h"
37
38 Bool_t AliEMCALTrack::fgUseOuterParams = kTRUE;
39 Bool_t AliEMCALTrack::fgCorrectForEL   = kFALSE;
40 Bool_t AliEMCALTrack::fgSortByPt       = kTRUE;
41
42 ClassImp(AliEMCALTrack)
43 //
44 //------------------------------------------------------------------------------
45 //
46 AliEMCALTrack::AliEMCALTrack() 
47   : AliExternalTrackParam(),
48     fClusterIndex(-1),
49     fClusterDist(1000.0),          // default: extremely large distance
50     fMass(0.13957018),             // default: pion mass
51     fSeedIndex(-1),
52     fSeedLabel(-1)
53 {
54         //
55         // Default constructor.
56         // Sets to meaningless values the indexes corresponding to
57         // ESD seed track and matched cluster.
58         //
59 }
60 //
61 //------------------------------------------------------------------------------
62 //
63 AliEMCALTrack::AliEMCALTrack(const AliESDtrack& t) 
64   : AliExternalTrackParam(),
65     fClusterIndex(-1),
66     fClusterDist(1000.0),
67     fMass(t.GetMass()),
68     fSeedIndex(-1),
69     fSeedLabel(t.GetLabel())
70 {
71         //
72         // Constructor from AliESDtrack
73         //
74
75         // parameters are chosen according to static variable fUseOuterParams
76         Double_t alpha, x, params[5], cov[15];
77         if (fgUseOuterParams) {
78                 t.GetOuterExternalParameters(alpha, x, params);
79                 t.GetOuterExternalCovariance(cov);
80         }
81         else {
82                 alpha = t.GetAlpha();
83                 t.GetExternalParameters(x, params);
84                 t.GetExternalCovariance(cov);
85         }
86         
87         if (alpha < -TMath::Pi()) alpha += TMath::TwoPi();
88         else if (alpha >= TMath::Pi()) alpha -= TMath::TwoPi();
89         
90         // set this accordingly
91         Set(x, alpha, params, cov);
92 }
93 //
94 //------------------------------------------------------------------------------
95 //
96 AliEMCALTrack::AliEMCALTrack(const AliEMCALTrack& t) 
97   : AliExternalTrackParam(t),
98     fClusterIndex(t.fClusterIndex),
99     fClusterDist(t.fClusterDist),
100     fMass(t.fMass),
101     fSeedIndex(t.fSeedIndex),
102     fSeedLabel(t.fSeedLabel)
103 {
104         //
105         // Copy constructor.
106         //
107 }
108 //
109 //------------------------------------------------------------------------------
110 //
111 AliEMCALTrack& AliEMCALTrack::operator=(const AliEMCALTrack &t)
112 {
113         //
114         // Assignment operator
115         // Works like copy constructor
116         //
117         
118         fClusterIndex = t.fClusterIndex;
119         fClusterDist = t.fClusterDist;
120         
121         fMass = t.fMass;
122         
123         fSeedIndex = t.fSeedIndex;
124         fSeedLabel = t.fSeedLabel;
125
126         return *this;
127 }
128 //
129 //------------------------------------------------------------------------------
130 //
131 Int_t AliEMCALTrack::Compare(const TObject *obj) const 
132 {
133         //
134         // Compare tracks.
135         // How tracks are compared depends on the static flag
136         // "fSortByPt" (boolean):
137         // true  => tracks are compared w.r. to their transverse momentum
138         // false => tracks are compared w.r. to their distance from cluster
139         //
140         
141         AliEMCALTrack *that = (AliEMCALTrack*)obj;
142         
143         Double_t thisP[3], thisVal, thatP[3], thatVal;
144         
145         if (fgSortByPt) {
146                 this->GetPxPyPz(thisP);
147                 that->GetPxPyPz(thatP); 
148                 thisVal = TMath::Sqrt(thisP[0]*thisP[0] + thisP[1]*thisP[1]);
149                 thatVal = TMath::Sqrt(thatP[0]*thatP[0] + thatP[1]*thatP[1]);
150         }
151         else {
152                 thisVal = this->GetClusterDist();
153                 thatVal = that->GetClusterDist();
154         }
155         
156         if (thisVal > thatVal) return 1;
157         else if (thisVal < thatVal) return -1;
158         else return 0;
159 }
160 //
161 //------------------------------------------------------------------------------
162 //
163 Double_t AliEMCALTrack::GetBz() const 
164 {
165         //
166         // Returns Z-component of the magnetic field in kG.
167         // In case it B is not constant, its value is returned
168         // at the current position of the track (local X,Y,Z)
169         //
170         
171         // if magnetic field is constant...
172         if (AliTracker::UniformField()) return AliTracker::GetBz();
173         
174         // ...else:
175         Double_t r[3];
176         GetXYZ(r);
177         return AliTracker::GetBz(r);
178 }
179 //
180 //------------------------------------------------------------------------------
181 //
182 Bool_t AliEMCALTrack::PropagateTo(Double_t xk, Double_t d, Double_t x0)
183 {
184         //
185         // Propagates a track to the plane defined by x='xk'.
186         // Second parameter is the width (in units of rad. length) crossed by the track.
187         // Third parameter is the reference radiation length used.
188         // Track propagation includes computing energy loss (modifies curvature)
189         // and multiple scattering perturbation (alters covariance matrix), if requested.
190         // Method returns kFALSE when something goes wrong with computations.
191         //
192         // An additional operation (thanks to Yuri Belikov) is done to check
193         // when the track crosses a sector boundary. If this happens, 
194         // the local track reference frame is adjusted accordingly.
195         //
196                 
197         Double_t y;
198         Double_t field = GetBz();
199         Double_t width = TMath::Pi() / 9.0; // width of TPC/TRD/EMCAL sector (= 20 deg)
200         Double_t ymax  = TMath::Abs(xk * TMath::Tan(0.5 * width)); // max allowed Y in local coords at distance xk
201         
202         // first check: try to compute the local 'y' at the distance 'xk':
203         // if this attempt fails, the propagation cannot be done
204         if (!GetYAt(xk, field, y)) return kFALSE;
205         
206         // if is -ymax < y < ymax ==> 'direct' propagation is done;
207         if (TMath::Abs(y) <= ymax) return SimplePropagation(xk, d, x0);
208         
209         // otherwise, try change a sector to find one where the propagation is ok
210         Int_t    i, incr, istart, nloops;
211         Double_t alpha = GetAlpha();
212         incr = (y > ymax) ? 1 : -1;
213         if (alpha < 0.0) alpha += TMath::TwoPi();
214         istart = (Int_t)(alpha / width);
215         for (i = istart, nloops = 0; nloops < 18; i += incr, nloops++) {
216                 if (i == 18) i = 0;
217                 if (i == -1) i = 17;
218                 alpha = ((Double_t)i + 0.5) * width;
219                 if (Rotate(alpha)) {
220                         if (GetYAt(xk, field, y)) {
221                                 if (TMath::Abs(y) <= ymax) {
222                                   AliDebug(1,Form("Required change from sector %d to sector %d to succeed in propagation", istart, i));
223                                         return SimplePropagation(xk, d, x0);
224                                 }
225                         }
226                 }
227         }
228         
229         // if the routine exits from the loop and reaches this point,
230         // it means that none of the rotations succeeded
231         AliWarning("Track propagation fails in every sector. Impossible to propagate.");
232         return kFALSE;
233 }
234 //
235 //------------------------------------------------------------------------------
236 //
237 Double_t AliEMCALTrack::StraightPropagateTo(Double_t xk, Double_t &x, Double_t &y, Double_t &z)
238 {
239         //
240         // Does propagation with a straight line approximation.
241         // This operation does not update track parameters, but it returns a point
242         // in space, according to this propagation, which is stored in
243         // the arguments #2, #3 and #4
244         //
245         
246         Double_t oldX = GetX(), oldY = GetY(), oldZ = GetZ();
247         Double_t newPos[3];
248         
249         newPos[0] = xk;
250         newPos[1] = oldY * xk / oldX;
251         newPos[2] = oldZ * xk / oldX;
252         
253         Double_t cs = TMath::Cos(GetAlpha()), sn = TMath::Sin(GetAlpha());
254         x = newPos[0]*cs - newPos[1]*sn;
255         y = newPos[0]*sn + newPos[1]*cs;
256         z = newPos[2];
257         
258         return newPos[1];
259 }
260 //
261 //------------------------------------------------------------------------------
262 //
263 Bool_t AliEMCALTrack::PropagateToGlobal(Double_t x, Double_t y, Double_t z, Double_t d, Double_t x0)
264 {
265         //
266         // Propagate to a point specified with its global XYZ coordinates.
267         // Here, the correct value of the 'X' parameter to be sent to "PropagateTo" is computed.
268         //
269         
270         TVector3 vc(x, y, z);
271         Double_t width = 20.0; // width of TPC/TRD/EMCAL sector
272         Double_t phi   = vc.Phi() * TMath::RadToDeg();
273         if (phi < 0.0) phi += 360.0;
274         
275         Int_t    isector = (Int_t)(phi / width);
276         Double_t rotation = ((Double_t)isector + 0.5) * width;
277         vc.RotateZ(-rotation * TMath::DegToRad());
278         
279         return PropagateTo(vc.X(), d, x0);
280 }
281 //
282 //------------------------------------------------------------------------------
283 //
284 Bool_t AliEMCALTrack::SimplePropagation(Double_t xk, Double_t d, Double_t x0)
285 {
286         //
287         // Recall base class method for track propagation.
288         //
289         
290         Double_t field = GetBz();
291         
292         // propagation...
293         if (!AliExternalTrackParam::PropagateTo(xk, field)) return kFALSE;
294         
295         // EL correction is computed only if requested...
296         if (!fgCorrectForEL) return kTRUE;
297         return AliExternalTrackParam::CorrectForMaterial(d, x0, GetMass());
298 }