3 // Author: Anders Vestbo <mailto:vestbo$fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
4 //*-- Copyright © ALICE HLT Group
6 #include "AliL3StandardIncludes.h"
8 #include "AliL3RootTypes.h"
9 #include "AliL3Logging.h"
10 #include "AliL3Track.h"
11 #include "AliL3Transform.h"
12 #include "AliL3Vertex.h"
13 #include "AliL3SpacePointData.h"
21 //_____________________________________________________________
26 //<img src="track_coordinates.gif">
34 AliL3Track::AliL3Track()
44 ComesFromMainVertex(false);
58 memset(fHitNumbers,0,159*sizeof(UInt_t));
62 void AliL3Track::Set(AliL3Track *tpt){
64 SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
65 SetPhi0(tpt->GetPhi0());
66 SetKappa(tpt->GetKappa());
67 SetNHits(tpt->GetNHits());
68 SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
69 SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ());
71 SetPsi(tpt->GetPsi());
72 SetTgl(tpt->GetTgl());
73 SetCharge(tpt->GetCharge());
74 SetHits(tpt->GetNHits(),(UInt_t *)tpt->GetHitNumbers());
76 SetMCid(tpt->GetMCid());
78 SetPID(tpt->GetPID());
79 SetSector(tpt->GetSector());
82 Int_t AliL3Track::Compare(const AliL3Track *track) const
84 if(track->GetNHits() < GetNHits()) return 1;
85 if(track->GetNHits() > GetNHits()) return -1;
89 AliL3Track::~AliL3Track()
94 Double_t AliL3Track::GetP() const
96 // Returns total momentum.
97 return fabs(GetPt())*sqrt(1. + GetTgl()*GetTgl());
100 Double_t AliL3Track::GetPseudoRapidity() const
102 return 0.5 * log((GetP() + GetPz()) / (GetP() - GetPz()));
106 Double_t AliL3Track::GetEta() const
108 return GetPseudoRapidity();
112 Double_t AliL3Track::GetRapidity() const
114 const Double_t m_pi = 0.13957;
115 return 0.5 * log((m_pi + GetPz()) / (m_pi - GetPz()));
118 void AliL3Track::Rotate(Int_t slice,Bool_t tolocal)
120 //Rotate track to global parameters
121 //If flag tolocal is set, the track is rotated
122 //to local coordinates.
125 Float_t psi[1] = {GetPsi()};
127 AliL3Transform::Local2GlobalAngle(psi,slice);
129 AliL3Transform::Global2LocalAngle(psi,slice);
132 first[0] = GetFirstPointX();
133 first[1] = GetFirstPointY();
134 first[2] = GetFirstPointZ();
136 AliL3Transform::Local2Global(first,slice);
138 AliL3Transform::Global2LocHLT(first,slice);
139 //AliL3Transform::Global2Local(first,slice,kTRUE);
141 SetFirstPoint(first[0],first[1],first[2]);
143 last[0] = GetLastPointX();
144 last[1] = GetLastPointY();
145 last[2] = GetLastPointZ();
147 AliL3Transform::Local2Global(last,slice);
149 AliL3Transform::Global2LocHLT(last,slice);
150 //AliL3Transform::Global2Local(last,slice,kTRUE);
151 SetLastPoint(last[0],last[1],last[2]);
153 Float_t center[3] = {GetCenterX(),GetCenterY(),0};
155 AliL3Transform::Local2Global(center,slice);
157 AliL3Transform::Global2LocHLT(center,slice);
158 //AliL3Transform::Global2Local(center,slice,kTRUE);
159 SetCenterX(center[0]);
160 SetCenterY(center[1]);
162 SetPhi0(atan2(fFirstPoint[1],fFirstPoint[0]));
163 SetR0(sqrt(fFirstPoint[0]*fFirstPoint[0]+fFirstPoint[1]*fFirstPoint[1]));
171 void AliL3Track::CalculateHelix(){
172 //Calculate Radius, CenterX and CenterY from Psi, X0, Y0
175 fRadius = fPt / (AliL3Transform::GetBFieldValue());
176 if(fRadius) fKappa = -fQ*1./fRadius;
177 else fRadius = 999999; //just zero
178 Double_t trackPhi0 = fPsi + fQ * AliL3Transform::PiHalf();
180 fCenterX = fFirstPoint[0] - fRadius * cos(trackPhi0);
181 fCenterY = fFirstPoint[1] - fRadius * sin(trackPhi0);
183 SetPhi0(atan2(fFirstPoint[1],fFirstPoint[0]));
184 SetR0(sqrt(fFirstPoint[0]*fFirstPoint[0]+fFirstPoint[1]*fFirstPoint[1]));
187 Double_t AliL3Track::GetCrossingAngle(Int_t padrow,Int_t slice)
189 //Calculate the crossing angle between track and given padrow.
190 //Take the dot product of the tangent vector of the track, and
191 //vector perpendicular to the padrow.
192 //In order to do this, we need the tangent vector to the track at the
193 //point. This is done by rotating the radius vector by 90 degrees;
194 //rotation matrix: ( 0 1 )
197 Float_t angle=0;//Angle perpendicular to the padrow in local coordinates
198 if(slice>=0)//Global coordinates
200 AliL3Transform::Local2GlobalAngle(&angle,slice);
201 if(!CalculateReferencePoint(angle,AliL3Transform::Row2X(padrow)))
202 cerr<<"AliL3Track::GetCrossingAngle : Track does not cross line in slice "<<slice<<" row "<<padrow<<endl;
204 else //should be in local coordinates
207 GetCrossingPoint(padrow,xyz);
215 tangent[0] = (fPoint[1] - GetCenterY())/GetRadius();
216 tangent[1] = -1.*(fPoint[0] - GetCenterX())/GetRadius();
218 Double_t perp_padrow[2] = {cos(angle),sin(angle)};
220 Double_t cos_beta = fabs(tangent[0]*perp_padrow[0] + tangent[1]*perp_padrow[1]);
221 if(cos_beta > 1) cos_beta=1;
222 return acos(cos_beta);
225 Bool_t AliL3Track::GetCrossingPoint(Int_t padrow,Float_t *xyz)
227 //Assumes the track is given in local coordinates
231 cerr<<"GetCrossingPoint: Track is given on global coordinates"<<endl;
235 Double_t xHit = AliL3Transform::Row2X(padrow);
238 Double_t aa = (xHit - GetCenterX())*(xHit - GetCenterX());
239 Double_t r2 = GetRadius()*GetRadius();
243 Double_t aa2 = sqrt(r2 - aa);
244 Double_t y1 = GetCenterY() + aa2;
245 Double_t y2 = GetCenterY() - aa2;
247 if(fabs(y2) < fabs(y1)) xyz[1] = y2;
249 Double_t yHit = xyz[1];
250 Double_t angle1 = atan2((yHit - GetCenterY()),(xHit - GetCenterX()));
251 if(angle1 < 0) angle1 += 2.*AliL3Transform::Pi();
252 Double_t angle2 = atan2((GetFirstPointY() - GetCenterY()),(GetFirstPointX() - GetCenterX()));
253 if(angle2 < 0) angle2 += AliL3Transform::TwoPi();
254 Double_t diff_angle = angle1 - angle2;
255 diff_angle = fmod(diff_angle,AliL3Transform::TwoPi());
256 if((GetCharge()*diff_angle) > 0) diff_angle = diff_angle - GetCharge()*AliL3Transform::TwoPi();
257 Double_t s_tot = fabs(diff_angle)*GetRadius();
258 Double_t zHit = GetFirstPointZ() + s_tot*GetTgl();
265 Bool_t AliL3Track::CalculateReferencePoint(Double_t angle,Double_t radius){
266 // Global coordinate: crossing point with y = ax+ b;
267 // a=tan(angle-AliL3Transform::PiHalf());
269 const Double_t rr=radius; //position of reference plane
270 const Double_t xr = cos(angle) * rr;
271 const Double_t yr = sin(angle) * rr;
273 Double_t a = tan(angle-AliL3Transform::PiHalf());
274 Double_t b = yr - a * xr;
276 Double_t pp=(fCenterX+a*fCenterY-a*b)/(1+pow(a,2));
277 Double_t qq=(pow(fCenterX,2)+pow(fCenterY,2)-2*fCenterY*b+pow(b,2)-pow(fRadius,2))/(1+pow(a,2));
279 Double_t racine = pp*pp-qq;
280 if(racine<0) return IsPoint(kFALSE); //no Point
282 Double_t rootRacine = sqrt(racine);
283 Double_t x0 = pp+rootRacine;
284 Double_t x1 = pp-rootRacine;
285 Double_t y0 = a*x0 + b;
286 Double_t y1 = a*x1 + b;
288 Double_t diff0 = sqrt(pow(x0-xr,2)+pow(y0-yr,2));
289 Double_t diff1 = sqrt(pow(x1-xr,2)+pow(y1-yr,2));
300 Double_t pointPhi0 = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
301 Double_t trackPhi0 = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
302 if(fabs(trackPhi0-pointPhi0)>AliL3Transform::Pi()){
303 if(trackPhi0<pointPhi0) trackPhi0 += AliL3Transform::TwoPi();
304 else pointPhi0 += AliL3Transform::TwoPi();
306 Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;
307 fPoint[2] = fFirstPoint[2] + stot * fTanl;
309 fPointPsi = pointPhi0 - fQ * AliL3Transform::PiHalf();
310 if(fPointPsi<0.) fPointPsi+= AliL3Transform::TwoPi();
311 fPointPsi = fmod(fPointPsi, AliL3Transform::TwoPi());
313 return IsPoint(kTRUE);
316 Bool_t AliL3Track::CalculateEdgePoint(Double_t angle){
317 // Global coordinate: crossing point with y = ax; a=tan(angle);
319 Double_t rmin=AliL3Transform::Row2X(AliL3Transform::GetFirstRow(-1)); //min Radius of TPC
320 Double_t rmax=AliL3Transform::Row2X(AliL3Transform::GetLastRow(-1)); //max Radius of TPC
322 Double_t a = tan(angle);
323 Double_t pp=(fCenterX+a*fCenterY)/(1+pow(a,2));
324 Double_t qq=(pow(fCenterX,2)+pow(fCenterY,2)-pow(fRadius,2))/(1+pow(a,2));
325 Double_t racine = pp*pp-qq;
326 if(racine<0) return IsPoint(kFALSE); //no Point
327 Double_t rootRacine = sqrt(racine);
328 Double_t x0 = pp+rootRacine;
329 Double_t x1 = pp-rootRacine;
333 Double_t r0 = sqrt(pow(x0,2)+pow(y0,2));
334 Double_t r1 = sqrt(pow(x1,2)+pow(y1,2));
335 //find the right crossing point:
336 //inside the TPC modules
340 if(r0>rmin&&r0<rmax){
341 Double_t da=atan2(y0,x0);
342 if(da<0) da+=AliL3Transform::TwoPi();
343 if(fabs(da-angle)<0.5)
346 if(r1>rmin&&r1<rmax){
347 Double_t da=atan2(y1,x1);
348 if(da<0) da+=AliL3Transform::TwoPi();
349 if(fabs(da-angle)<0.5)
352 if(!(ok0||ok1)) return IsPoint(kFALSE); //no Point
355 Double_t diff0 = sqrt(pow(fFirstPoint[0]-x0,2)+pow(fFirstPoint[1]-y0,2));
356 Double_t diff1 = sqrt(pow(fFirstPoint[0]-x1,2)+pow(fFirstPoint[1]-y1,2));
357 if(diff0<diff1) ok1 = kFALSE; //use ok0
358 else ok0 = kFALSE; //use ok1
360 if(ok0){fPoint[0]=x0; fPoint[1]=y0;}
361 else {fPoint[0]=x1; fPoint[1]=y1;}
363 Double_t pointPhi0 = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
364 Double_t trackPhi0 = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
365 if(fabs(trackPhi0-pointPhi0)>AliL3Transform::Pi()){
366 if(trackPhi0<pointPhi0) trackPhi0 += AliL3Transform::TwoPi();
367 else pointPhi0 += AliL3Transform::TwoPi();
369 Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;
370 fPoint[2] = fFirstPoint[2] + stot * fTanl;
372 fPointPsi = pointPhi0 - fQ * AliL3Transform::PiHalf();
373 if(fPointPsi<0.) fPointPsi+= AliL3Transform::TwoPi();
374 fPointPsi = fmod(fPointPsi, AliL3Transform::TwoPi());
376 return IsPoint(kTRUE);
379 Bool_t AliL3Track::CalculatePoint(Double_t xplane){
380 // Local coordinate: crossing point with x plane
382 Double_t racine = pow(fRadius,2)-pow(xplane-fCenterX,2);
383 if(racine<0) return IsPoint(kFALSE);
384 Double_t rootRacine = sqrt(racine);
386 Double_t y0 = fCenterY + rootRacine;
387 Double_t y1 = fCenterY - rootRacine;
388 //Double_t diff0 = sqrt(pow(fFirstPoint[0]-xplane)+pow(fFirstPoint[1]-y0));
389 //Double_t diff1 = sqrt(pow(fFirstPoint[0]-xplane)+pow(fFirstPoint[1]-y1));
390 Double_t diff0 = fabs(y0-fFirstPoint[1]);
391 Double_t diff1 = fabs(y1-fFirstPoint[1]);
394 if(diff0<diff1) fPoint[1]=y0;
397 Double_t pointPhi0 = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
398 Double_t trackPhi0 = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
399 if(fabs(trackPhi0-pointPhi0)>AliL3Transform::Pi()){
400 if(trackPhi0<pointPhi0) trackPhi0 += AliL3Transform::TwoPi();
401 else pointPhi0 += AliL3Transform::TwoPi();
403 Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;
404 fPoint[2] = fFirstPoint[2] + stot * fTanl;
406 fPointPsi = pointPhi0 - fQ * AliL3Transform::PiHalf();
407 if(fPointPsi<0.) fPointPsi+= AliL3Transform::TwoPi();
408 fPointPsi = fmod(fPointPsi, AliL3Transform::TwoPi());
410 return IsPoint(kTRUE);
413 void AliL3Track::UpdateToFirstPoint()
415 //Update track parameters to the innermost point on the track.
416 //This means that the parameters of the track will be given in the point
417 //of closest approach to the first innermost point, i.e. the point
418 //lying on the track fit (and not the coordinates of the innermost point itself).
419 //This function assumes that fFirstPoint is already set to the coordinates of the innermost
422 //During the helix-fit, the first point on the track is set to the coordinates
423 //of the innermost assigned cluster. This may be ok, if you just want a fast
424 //estimate of the "global" track parameters; such as the momentum etc.
425 //However, if you later on want to do more precise local calculations, such
426 //as impact parameter, residuals etc, you need to give the track parameters
427 //according to the actual fit.
429 Double_t xc = GetCenterX() - GetFirstPointX();
430 Double_t yc = GetCenterY() - GetFirstPointY();
432 Double_t dist_x1 = xc*(1 + GetRadius()/sqrt(xc*xc + yc*yc));
433 Double_t dist_y1 = yc*(1 + GetRadius()/sqrt(xc*xc + yc*yc));
434 Double_t distance1 = sqrt(dist_x1*dist_x1 + dist_y1*dist_y1);
436 Double_t dist_x2 = xc*(1 - GetRadius()/sqrt(xc*xc + yc*yc));
437 Double_t dist_y2 = yc*(1 - GetRadius()/sqrt(xc*xc + yc*yc));
438 Double_t distance2 = sqrt(dist_x2*dist_x2 + dist_y2*dist_y2);
440 //Choose the closest:
442 if(distance1 < distance2)
444 point[0] = dist_x1 + GetFirstPointX();
445 point[1] = dist_y1 + GetFirstPointY();
449 point[0] = dist_x2 + GetFirstPointX();
450 point[1] = dist_y2 + GetFirstPointY();
453 Double_t pointpsi = atan2(point[1]-GetCenterY(),point[0]-GetCenterX());
454 pointpsi -= GetCharge()*AliL3Transform::PiHalf();
455 if(pointpsi < 0) pointpsi += AliL3Transform::TwoPi();
457 //Update the track parameters
458 SetR0(sqrt(point[0]*point[0]+point[1]*point[1]));
459 SetPhi0(atan2(point[1],point[0]));
460 SetFirstPoint(point[0],point[1],GetZ0());
465 void AliL3Track::GetClosestPoint(AliL3Vertex *vertex,Double_t &closest_x,Double_t &closest_y,Double_t &closest_z)
467 //Calculate the point of closest approach to the vertex
468 //This function calculates the minimum distance from the helix to the vertex, and choose
469 //the corresponding point lying on the helix as the point of closest approach.
471 Double_t xc = GetCenterX() - vertex->GetX();
472 Double_t yc = GetCenterY() - vertex->GetY();
474 Double_t dist_x1 = xc*(1 + GetRadius()/sqrt(xc*xc + yc*yc));
475 Double_t dist_y1 = yc*(1 + GetRadius()/sqrt(xc*xc + yc*yc));
476 Double_t distance1 = sqrt(dist_x1*dist_x1 + dist_y1*dist_y1);
478 Double_t dist_x2 = xc*(1 - GetRadius()/sqrt(xc*xc + yc*yc));
479 Double_t dist_y2 = yc*(1 - GetRadius()/sqrt(xc*xc + yc*yc));
480 Double_t distance2 = sqrt(dist_x2*dist_x2 + dist_y2*dist_y2);
482 //Choose the closest:
483 if(distance1 < distance2)
485 closest_x = dist_x1 + vertex->GetX();
486 closest_y = dist_y1 + vertex->GetY();
490 closest_x = dist_x2 + vertex->GetX();
491 closest_y = dist_y2 + vertex->GetY();
494 //Get the z coordinate:
495 Double_t angle1 = atan2((closest_y-GetCenterY()),(closest_x-GetCenterX()));
496 if(angle1 < 0) angle1 = angle1 + AliL3Transform::TwoPi();
498 Double_t angle2 = atan2((GetFirstPointY()-GetCenterY()),(GetFirstPointX()-GetCenterX()));
499 if(angle2 < 0) angle2 = angle2 + AliL3Transform::TwoPi();
501 Double_t diff_angle = angle1 - angle2;
502 diff_angle = fmod(diff_angle,AliL3Transform::TwoPi());
504 if((GetCharge()*diff_angle) < 0) diff_angle = diff_angle + GetCharge()*AliL3Transform::TwoPi();
505 Double_t s_tot = fabs(diff_angle)*GetRadius();
507 closest_z = GetFirstPointZ() - s_tot*GetTgl();