Line data Source code
1 : // $Id: AliHLTTPCGMTrackParam.cxx 41769 2010-06-16 13:58:00Z sgorbuno $
2 : // **************************************************************************
3 : // This file is property of and copyright by the ALICE HLT Project *
4 : // ALICE Experiment at CERN, All rights reserved. *
5 : // *
6 : // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 : // for The ALICE HLT Project. *
8 : // *
9 : // Permission to use, copy, modify and distribute this software and its *
10 : // documentation strictly for non-commercial purposes is hereby granted *
11 : // without fee, provided that the above copyright notice appears in all *
12 : // copies and that both the copyright notice and this permission notice *
13 : // appear in the supporting documentation. The authors make no claims *
14 : // about the suitability of this software for any purpose. It is *
15 : // provided "as is" without express or implied warranty. *
16 : // *
17 : //***************************************************************************
18 :
19 : #include "AliHLTTPCGMTrackParam.h"
20 : #include "AliHLTTPCCAMath.h"
21 : #include "AliHLTTPCGMTrackLinearisation.h"
22 : #include "AliHLTTPCGMBorderTrack.h"
23 : #include "Riostream.h"
24 : #ifndef HLTCA_STANDALONE
25 : #include "AliExternalTrackParam.h"
26 : #endif
27 : #include "AliHLTTPCCAParam.h"
28 : #include <cmath>
29 :
30 : GPUd() void AliHLTTPCGMTrackParam::Fit
31 : (
32 : float* PolinomialFieldBz,
33 : float x[], float y[], float z[], unsigned int rowType[], float alpha[], AliHLTTPCCAParam ¶m,
34 : int &N,
35 : float &Alpha,
36 : bool UseMeanPt,
37 : float maxSinPhi
38 : ){
39 :
40 : const float kRho = 1.025e-3;//0.9e-3;
41 : const float kRadLen = 29.532;//28.94;
42 : const float kRhoOverRadLen = kRho / kRadLen;
43 :
44 0 : AliHLTTPCGMTrackLinearisation t0(*this);
45 :
46 : const float kZLength = 250.f - 0.275f;
47 0 : float trDzDs2 = t0.DzDs()*t0.DzDs();
48 :
49 0 : AliHLTTPCGMTrackFitParam par;
50 0 : CalculateFitParameters( par, kRhoOverRadLen, kRho, UseMeanPt );
51 :
52 0 : int maxN = N;
53 :
54 : bool first = 1;
55 0 : N = 0;
56 :
57 0 : for( int ihit=0; ihit<maxN; ihit++ ){
58 :
59 0 : float sliceAlpha = alpha[ihit];
60 :
61 0 : if ( fabs( sliceAlpha - Alpha ) > 1.e-4 ) {
62 0 : if( !Rotate( sliceAlpha - Alpha, t0, .999 ) ) break;
63 0 : Alpha = sliceAlpha;
64 0 : }
65 :
66 : float dL=0;
67 0 : float bz = GetBz(x[ihit], y[ihit],z[ihit], PolinomialFieldBz);
68 :
69 : float err2Y, err2Z;
70 :
71 : { // transport block
72 :
73 0 : bz = -bz;
74 :
75 0 : float ex = t0.CosPhi();
76 :
77 0 : float ey = t0.SinPhi();
78 0 : float k = t0.QPt()*bz;
79 0 : float dx = x[ihit] - X();
80 0 : float kdx = k*dx;
81 0 : float ey1 = kdx + ey;
82 :
83 0 : if( fabs( ey1 ) >= maxSinPhi ) break;
84 :
85 0 : float ss = ey + ey1;
86 0 : float ex1 = sqrt(1 - ey1*ey1);
87 :
88 0 : float dxBz = dx * bz;
89 :
90 0 : float cc = ex + ex1;
91 0 : float dxcci = dx * Reciprocal(cc);
92 0 : float kdx205 = kdx*kdx*0.5f;
93 :
94 0 : float dy = dxcci * ss;
95 0 : float norm2 = float(1.f) + ey*ey1 + ex*ex1;
96 0 : float dl = dxcci * sqrt( norm2 + norm2 );
97 :
98 : float dS;
99 : {
100 0 : float dSin = float(0.5f)*k*dl;
101 0 : float a = dSin*dSin;
102 : const float k2 = 1.f/6.f;
103 : const float k4 = 3.f/40.f;
104 : //const float k6 = 5.f/112.f;
105 0 : dS = dl + dl*a*(k2 + a*(k4 ));//+ k6*a) );
106 : }
107 :
108 0 : float ex1i = Reciprocal(ex1);
109 0 : float dz = dS * t0.DzDs();
110 :
111 0 : dL = -dS * t0.DlDs();
112 :
113 0 : float hh = dxcci*ex1i*(2.f+kdx205);
114 0 : float h2 = hh * t0.SecPhi();
115 0 : float h4 = bz*dxcci*hh;
116 :
117 0 : float d2 = fP[2] - t0.SinPhi();
118 0 : float d3 = fP[3] - t0.DzDs();
119 0 : float d4 = fP[4] - t0.QPt();
120 :
121 :
122 0 : fX+=dx;
123 0 : fP[0]+= dy + h2 * d2 + h4 * d4;
124 0 : fP[1]+= dz + dS * d3;
125 0 : fP[2] = ey1 + d2 + dxBz * d4;
126 :
127 0 : t0.CosPhi() = ex1;
128 0 : t0.SecPhi() = ex1i;
129 0 : t0.SinPhi() = ey1;
130 :
131 : {
132 0 : const float *cy = param.GetParamS0Par(0,rowType[ihit]);
133 0 : const float *cz = param.GetParamS0Par(1,rowType[ihit]);
134 :
135 0 : float secPhi2 = ex1i*ex1i;
136 0 : float zz = fabs( kZLength - fabs(fP[2]) );
137 0 : float zz2 = zz*zz;
138 0 : float angleY2 = secPhi2 - 1.f;
139 0 : float angleZ2 = trDzDs2 * secPhi2 ;
140 :
141 0 : float cy0 = cy[0] + cy[1]*zz + cy[3]*zz2;
142 0 : float cy1 = cy[2] + cy[5]*zz;
143 0 : float cy2 = cy[4];
144 0 : float cz0 = cz[0] + cz[1]*zz + cz[3]*zz2;
145 0 : float cz1 = cz[2] + cz[5]*zz;
146 0 : float cz2 = cz[4];
147 :
148 0 : err2Y = fabs( cy0 + angleY2 * ( cy1 + angleY2*cy2 ) );
149 0 : err2Z = fabs( cz0 + angleZ2 * ( cz1 + angleZ2*cz2 ) );
150 : }
151 :
152 :
153 0 : if ( first ) {
154 0 : fP[0] = y[ihit];
155 0 : fP[1] = z[ihit];
156 0 : SetCov( 0, err2Y );
157 0 : SetCov( 1, 0 );
158 0 : SetCov( 2, err2Z);
159 0 : SetCov( 3, 0 );
160 0 : SetCov( 4, 0 );
161 0 : SetCov( 5, 1 );
162 0 : SetCov( 6, 0 );
163 0 : SetCov( 7, 0 );
164 0 : SetCov( 8, 0 );
165 0 : SetCov( 9, 1 );
166 0 : SetCov( 10, 0 );
167 0 : SetCov( 11, 0 );
168 0 : SetCov( 12, 0 );
169 0 : SetCov( 13, 0 );
170 0 : SetCov( 14, 10 );
171 0 : SetChi2( 0 );
172 0 : SetNDF( -3 );
173 0 : CalculateFitParameters( par, kRhoOverRadLen, kRho, UseMeanPt );
174 : first = 0;
175 0 : N+=1;
176 0 : continue;
177 : }
178 :
179 0 : float c20 = fC[3];
180 0 : float c21 = fC[4];
181 0 : float c22 = fC[5];
182 0 : float c30 = fC[6];
183 0 : float c31 = fC[7];
184 0 : float c32 = fC[8];
185 0 : float c33 = fC[9];
186 0 : float c40 = fC[10];
187 0 : float c41 = fC[11];
188 0 : float c42 = fC[12];
189 0 : float c43 = fC[13];
190 0 : float c44 = fC[14];
191 :
192 0 : float c20ph4c42 = c20 + h4*c42;
193 0 : float h2c22 = h2*c22;
194 0 : float h4c44 = h4*c44;
195 :
196 0 : float n6 = c30 + h2*c32 + h4*c43;
197 0 : float n7 = c31 + dS*c33;
198 0 : float n10 = c40 + h2*c42 + h4c44;
199 0 : float n11 = c41 + dS*c43;
200 0 : float n12 = c42 + dxBz*c44;
201 :
202 0 : fC[8] = c32 + dxBz * c43;
203 :
204 0 : fC[0]+= h2*h2c22 + h4*h4c44 + float(2.f)*( h2*c20ph4c42 + h4*c40 );
205 :
206 0 : fC[1]+= h2*c21 + h4*c41 + dS*n6;
207 0 : fC[6] = n6;
208 :
209 0 : fC[2]+= dS*(c31 + n7);
210 0 : fC[7] = n7;
211 :
212 0 : fC[3] = c20ph4c42 + h2c22 + dxBz*n10;
213 0 : fC[10] = n10;
214 :
215 0 : fC[4] = c21 + dS*c32 + dxBz*n11;
216 0 : fC[11] = n11;
217 :
218 0 : fC[5] = c22 + dxBz*( c42 + n12 );
219 0 : fC[12] = n12;
220 :
221 0 : } // end transport block
222 :
223 :
224 0 : float &fC22 = fC[5];
225 0 : float &fC33 = fC[9];
226 0 : float &fC40 = fC[10];
227 0 : float &fC41 = fC[11];
228 0 : float &fC42 = fC[12];
229 0 : float &fC43 = fC[13];
230 0 : float &fC44 = fC[14];
231 :
232 : float
233 0 : c00 = fC[ 0],
234 0 : c11 = fC[ 2],
235 0 : c20 = fC[ 3],
236 0 : c31 = fC[ 7];
237 :
238 :
239 : // MS block
240 :
241 0 : float dLmask = 0.f;
242 0 : bool maskMS = ( fabs( dL ) < par.fDLMax );
243 :
244 :
245 : // Filter block
246 :
247 0 : float mS0 = Reciprocal(err2Y + c00);
248 :
249 : // MS block
250 0 : Assign( dLmask, maskMS, dL );
251 :
252 : // Filter block
253 :
254 0 : float z0 = y[ihit] - fP[0];
255 0 : float mS2 = Reciprocal(err2Z + c11);
256 :
257 0 : if( fabs( fP[2] + z0*c20*mS0 ) > maxSinPhi ) break;
258 :
259 : // MS block
260 :
261 0 : float dLabs = fabs( dLmask);
262 0 : float corr = float(1.f) - par.fEP2* dLmask ;
263 :
264 0 : fP[4]*= corr;
265 0 : fC40 *= corr;
266 0 : fC41 *= corr;
267 0 : fC42 *= corr;
268 0 : fC43 *= corr;
269 0 : fC44 = fC44*corr*corr + dLabs*par.fSigmadE2;
270 :
271 0 : fC22 += dLabs * par.fK22 * (float(1.f)-fP[2]*fP[2]);
272 0 : fC33 += dLabs * par.fK33;
273 0 : fC43 += dLabs * par.fK43;
274 :
275 :
276 : // Filter block
277 :
278 0 : float c40 = fC40;
279 :
280 : // K = CHtS
281 :
282 : float k00, k11, k20, k31, k40;
283 :
284 0 : k00 = c00 * mS0;
285 0 : k20 = c20 * mS0;
286 0 : k40 = c40 * mS0;
287 0 : fChi2 += mS0*z0*z0;
288 0 : fP[0] += k00 * z0;
289 0 : fP[2] += k20 * z0;
290 0 : fP[4] += k40 * z0;
291 0 : fC[ 0] -= k00 * c00 ;
292 0 : fC[ 5] -= k20 * c20 ;
293 0 : fC[10] -= k00 * c40 ;
294 0 : fC[12] -= k40 * c20 ;
295 0 : fC[ 3] -= k20 * c00 ;
296 0 : fC[14] -= k40 * c40 ;
297 :
298 0 : float z1 = z[ihit] - fP[1];
299 :
300 0 : k11 = c11 * mS2;
301 0 : k31 = c31 * mS2;
302 :
303 0 : fChi2 += mS2*z1*z1 ;
304 0 : fNDF += 2;
305 0 : N+=1;
306 :
307 0 : fP[1] += k11 * z1;
308 0 : fP[3] += k31 * z1;
309 :
310 0 : fC[ 7] -= k31 * c11;
311 0 : fC[ 2] -= k11 * c11;
312 0 : fC[ 9] -= k31 * c31;
313 0 : }
314 0 : }
315 :
316 : GPUd() bool AliHLTTPCGMTrackParam::CheckNumericalQuality() const
317 : {
318 : //* Check that the track parameters and covariance matrix are reasonable
319 :
320 0 : bool ok = AliHLTTPCCAMath::Finite(fX) && AliHLTTPCCAMath::Finite( fChi2 ) && AliHLTTPCCAMath::Finite( fNDF );
321 :
322 0 : const float *c = fC;
323 0 : for ( int i = 0; i < 15; i++ ) ok = ok && AliHLTTPCCAMath::Finite( c[i] );
324 0 : for ( int i = 0; i < 5; i++ ) ok = ok && AliHLTTPCCAMath::Finite( fP[i] );
325 :
326 0 : if ( c[0] <= 0 || c[2] <= 0 || c[5] <= 0 || c[9] <= 0 || c[14] <= 0 ) ok = 0;
327 0 : if ( c[0] > 5. || c[2] > 5. || c[5] > 2. || c[9] > 2.
328 : //|| ( CAMath::Abs( QPt() ) > 1.e-2 && c[14] > 2. )
329 0 : ) ok = 0;
330 :
331 0 : if ( fabs( fP[2] ) > .999 ) ok = 0;
332 0 : if ( fabs( fP[4] ) > 1. / 0.05 ) ok = 0;
333 0 : if( ok ){
334 0 : ok = ok
335 0 : && ( c[1]*c[1]<=c[2]*c[0] )
336 0 : && ( c[3]*c[3]<=c[5]*c[0] )
337 0 : && ( c[4]*c[4]<=c[5]*c[2] )
338 0 : && ( c[6]*c[6]<=c[9]*c[0] )
339 0 : && ( c[7]*c[7]<=c[9]*c[2] )
340 0 : && ( c[8]*c[8]<=c[9]*c[5] )
341 0 : && ( c[10]*c[10]<=c[14]*c[0] )
342 0 : && ( c[11]*c[11]<=c[14]*c[2] )
343 0 : && ( c[12]*c[12]<=c[14]*c[5] )
344 0 : && ( c[13]*c[13]<=c[14]*c[9] );
345 0 : }
346 0 : return ok;
347 : }
348 :
349 : //*
350 : //* Multiple scattering and energy losses
351 : //*
352 :
353 : GPUd() float AliHLTTPCGMTrackParam::ApproximateBetheBloch( float beta2 )
354 : {
355 : //------------------------------------------------------------------
356 : // This is an approximation of the Bethe-Bloch formula with
357 : // the density effect taken into account at beta*gamma > 3.5
358 : // (the approximation is reasonable only for solid materials)
359 : //------------------------------------------------------------------
360 :
361 0 : const float log0 = log( float(5940.f));
362 0 : const float log1 = log( float(3.5f*5940.f) );
363 :
364 0 : bool bad = (beta2 >= .999f)||( beta2 < 1.e-8f );
365 :
366 0 : Assign( beta2, bad, 0.5f);
367 :
368 0 : float a = beta2 / ( 1.f - beta2 );
369 0 : float b = 0.5*log(a);
370 0 : float d = 0.153e-3 / beta2;
371 0 : float c = b - beta2;
372 :
373 0 : float ret = d*(log0 + b + c );
374 0 : float case1 = d*(log1 + c );
375 :
376 0 : Assign( ret, ( a > 3.5*3.5 ), case1);
377 0 : Assign( ret, bad, 0. );
378 :
379 0 : return ret;
380 0 : }
381 :
382 : GPUd() void AliHLTTPCGMTrackParam::CalculateFitParameters( AliHLTTPCGMTrackFitParam &par, float RhoOverRadLen, float Rho, bool NoField, float mass )
383 : {
384 : //*!
385 :
386 0 : float qpt = fP[4];
387 0 : if( NoField ) qpt = 1./0.35;
388 :
389 0 : float p2 = ( 1. + fP[3] * fP[3] );
390 0 : float k2 = qpt * qpt;
391 0 : Assign( k2, ( k2 < 1.e-4f ), 1.e-4f );
392 :
393 0 : float mass2 = mass * mass;
394 0 : float beta2 = p2 / ( p2 + mass2 * k2 );
395 :
396 0 : float pp2 = p2 / k2; // impuls 2
397 :
398 : //par.fBethe = BetheBlochGas( pp2/mass2);
399 0 : par.fBetheRho = ApproximateBetheBloch( pp2 / mass2 )*Rho;
400 0 : par.fE = sqrt( pp2 + mass2 );
401 0 : par.fTheta2 = ( 14.1*14.1/1.e6 ) / ( beta2 * pp2 )*RhoOverRadLen;
402 0 : par.fEP2 = par.fE / pp2;
403 :
404 : // Approximate energy loss fluctuation (M.Ivanov)
405 :
406 : const float knst = 0.07; // To be tuned.
407 0 : par.fSigmadE2 = knst * par.fEP2 * qpt;
408 0 : par.fSigmadE2 = par.fSigmadE2 * par.fSigmadE2;
409 :
410 0 : float k22 = 1. + fP[3] * fP[3];
411 0 : par.fK22 = par.fTheta2*k22;
412 0 : par.fK33 = par.fK22 * k22;
413 0 : par.fK43 = 0.;
414 0 : par.fK44 = par.fTheta2*fP[3] * fP[3] * k2;
415 :
416 0 : float br=1.e-8f;
417 0 : Assign( br, ( par.fBetheRho>1.e-8f ), par.fBetheRho );
418 0 : par.fDLMax = 0.3*par.fE * Reciprocal( br );
419 :
420 0 : par.fEP2*=par.fBetheRho;
421 0 : par.fSigmadE2 = par.fSigmadE2*par.fBetheRho+par.fK44;
422 0 : }
423 :
424 :
425 :
426 :
427 : //*
428 : //* Rotation
429 : //*
430 :
431 :
432 : GPUd() bool AliHLTTPCGMTrackParam::Rotate( float alpha, AliHLTTPCGMTrackLinearisation &t0, float maxSinPhi )
433 : {
434 : //* Rotate the coordinate system in XY on the angle alpha
435 :
436 0 : float cA = CAMath::Cos( alpha );
437 0 : float sA = CAMath::Sin( alpha );
438 0 : float x0 = X(), y0 = Y(), sP = t0.SinPhi(), cP = t0.CosPhi();
439 0 : float cosPhi = cP * cA + sP * sA;
440 0 : float sinPhi = -cP * sA + sP * cA;
441 :
442 0 : if ( CAMath::Abs( sinPhi ) > maxSinPhi || CAMath::Abs( cosPhi ) < 1.e-2 || CAMath::Abs( cP ) < 1.e-2 ) return 0;
443 :
444 : //float J[5][5] = { { j0, 0, 0, 0, 0 }, // Y
445 : // { 0, 1, 0, 0, 0 }, // Z
446 : // { 0, 0, j2, 0, 0 }, // SinPhi
447 : // { 0, 0, 0, 1, 0 }, // DzDs
448 : // { 0, 0, 0, 0, 1 } }; // Kappa
449 :
450 0 : float j0 = cP / cosPhi;
451 0 : float j2 = cosPhi / cP;
452 0 : float d[2] = {Y() - y0, SinPhi() - sP};
453 :
454 0 : X() = ( x0*cA + y0*sA );
455 0 : Y() = ( -x0*sA + y0*cA + j0*d[0] );
456 0 : t0.CosPhi() = fabs( cosPhi );
457 0 : t0.SecPhi() = ( 1./t0.CosPhi() );
458 0 : t0.SinPhi() = ( sinPhi );
459 :
460 0 : SinPhi() = ( sinPhi + j2*d[1] );
461 :
462 0 : fC[0] *= j0 * j0;
463 0 : fC[1] *= j0;
464 0 : fC[3] *= j0;
465 0 : fC[6] *= j0;
466 0 : fC[10] *= j0;
467 :
468 0 : fC[3] *= j2;
469 0 : fC[4] *= j2;
470 0 : fC[5] *= j2 * j2;
471 0 : fC[8] *= j2;
472 0 : fC[12] *= j2;
473 0 : if( cosPhi <0 ){ // change direction
474 0 : t0.SinPhi() = -sinPhi;
475 0 : t0.DzDs() = -t0.DzDs();
476 0 : t0.DlDs() = -t0.DlDs();
477 0 : t0.QPt() = -t0.QPt();
478 0 : SinPhi() = -SinPhi();
479 0 : DzDs() = -DzDs();
480 0 : QPt() = -QPt();
481 0 : fC[3] = -fC[3];
482 0 : fC[4] = -fC[4];
483 0 : fC[6] = -fC[6];
484 0 : fC[7] = -fC[7];
485 0 : fC[10] = -fC[10];
486 0 : fC[11] = -fC[11];
487 0 : }
488 :
489 : return 1;
490 0 : }
491 :
492 : #if !defined(HLTCA_STANDALONE) & !defined(HLTCA_GPUCODE)
493 : bool AliHLTTPCGMTrackParam::GetExtParam( AliExternalTrackParam &T, double alpha ) const
494 : {
495 : //* Convert from AliHLTTPCGMTrackParam to AliExternalTrackParam parameterisation,
496 : //* the angle alpha is the global angle of the local X axis
497 :
498 0 : bool ok = CheckNumericalQuality();
499 :
500 0 : double par[5], cov[15];
501 0 : for ( int i = 0; i < 5; i++ ) par[i] = fP[i];
502 0 : for ( int i = 0; i < 15; i++ ) cov[i] = fC[i];
503 :
504 0 : if ( par[2] > .99 ) par[2] = .99;
505 0 : if ( par[2] < -.99 ) par[2] = -.99;
506 :
507 0 : if ( fabs( par[4] ) < 1.e-5 ) par[4] = 1.e-5; // some other software will crash if q/Pt==0
508 0 : if ( fabs( par[4] ) > 1./0.08 ) ok = 0; // some other software will crash if q/Pt is too big
509 :
510 0 : T.Set( (double) fX, alpha, par, cov );
511 0 : return ok;
512 0 : }
513 :
514 :
515 :
516 : void AliHLTTPCGMTrackParam::SetExtParam( const AliExternalTrackParam &T )
517 : {
518 : //* Convert from AliExternalTrackParam parameterisation
519 :
520 0 : for ( int i = 0; i < 5; i++ ) fP[i] = T.GetParameter()[i];
521 0 : for ( int i = 0; i < 15; i++ ) fC[i] = T.GetCovariance()[i];
522 0 : fX = T.GetX();
523 0 : if ( fP[2] > .999 ) fP[2] = .999;
524 0 : if ( fP[2] < -.999 ) fP[2] = -.999;
525 0 : }
526 : #endif
527 :
528 : #ifdef HLTCA_GPUCODE
529 :
530 : #include "AliHLTTPCGMMergedTrack.h"
531 :
532 : GPUg() void RefitTracks(AliHLTTPCGMMergedTrack* tracks, int nTracks, float* PolinomialFieldBz, float* x, float* y, float* z, unsigned int* rowType, float* alpha, AliHLTTPCCAParam* param)
533 : {
534 : for (int i = get_global_id(0);i < nTracks;i += get_global_size(0))
535 : {
536 : //This is in fact a copy of ReFit() in AliHLTTPCGMMerger.cxx
537 : AliHLTTPCGMMergedTrack& track = tracks[i];
538 : float Alpha = track.Alpha();
539 : int N = track.NClusters();
540 : AliHLTTPCGMTrackParam t = track.Param();
541 :
542 : t.Fit(PolinomialFieldBz,
543 : x+track.FirstClusterRef(),
544 : y+track.FirstClusterRef(),
545 : z+track.FirstClusterRef(),
546 : rowType+track.FirstClusterRef(),
547 : alpha+track.FirstClusterRef(),
548 : *param,
549 : N,
550 : Alpha,
551 : 0
552 : );
553 :
554 : if ( fabs( t.QPt() ) < 1.e-4 ) t.QPt() = 1.e-4 ;
555 :
556 : bool ok = N >= 30 && t.CheckNumericalQuality() && fabs( t.SinPhi() ) <= .999;
557 : track.SetOK(ok);
558 : if( !ok ) continue;
559 :
560 : if( 1 ){//SG!!!
561 : track.SetNClusters( N );
562 : track.Param() = t;
563 : track.Alpha() = Alpha;
564 : }
565 :
566 : {
567 : int ind = track.FirstClusterRef();
568 : float alphaalpha = alpha[ind];
569 : float xx = x[ind];
570 : float yy = y[ind];
571 : float zz = z[ind];
572 : float sinA = AliHLTTPCCAMath::Sin( alphaalpha - track.Alpha());
573 : float cosA = AliHLTTPCCAMath::Cos( alphaalpha - track.Alpha());
574 : track.SetLastX( xx*cosA - yy*sinA );
575 : track.SetLastY( xx*sinA + yy*cosA );
576 : track.SetLastZ( zz );
577 : }
578 : }
579 : }
580 :
581 : #endif
|
