[u/mrichter/AliRoot.git] / HLT / src / AliL3Track.cxx

//$Id$

// Author: Anders Vestbo <mailto:vestbo$fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright &copy ASV


#include "AliL3RootTypes.h"

#include "AliL3Logging.h"
#include "AliL3Track.h"
#include "AliL3Transform.h"
#include "AliL3Vertex.h"
#include <math.h>

//_____________________________________________________________
// AliL3Track
//
// Track base class
//Begin_Html
/*
<img src="track_coordinates.gif">
*/
//End_Html

ClassImp(AliL3Track)

Float_t AliL3Track::BFACT = 0.0029980;
Double_t AliL3Track::pi=3.14159265358979323846;

AliL3Track::AliL3Track()
{
  //Constructor

  fNHits = 0;
  fMCid = -1;
  fKappa=0;
  fRadius=0;
  fCenterX=0;
  fCenterY=0;
  ComesFromMainVertex(false);
  fQ = 0;
  fPhi0=0;
  fPsi=0;
  fR0=0;
  fTanl=0;
  fZ0=0;
  fPt=0;
  fLength=0;
  fIsLocal=true;
  fRowRange[0]=0;
  fRowRange[1]=0;
  memset(fHitNumbers,0,176*sizeof(UInt_t));
}

void AliL3Track::Set(AliL3Track *tpt){
  
  SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
  SetPhi0(tpt->GetPhi0());
  SetKappa(tpt->GetKappa());
  SetNHits(tpt->GetNHits());
  SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
  SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ());
  SetPt(tpt->GetPt());
  SetPsi(tpt->GetPsi());
  SetTgl(tpt->GetTgl());
  SetCharge(tpt->GetCharge());
  SetHits(tpt->GetNHits(),(UInt_t *)tpt->GetHitNumbers());
}

Int_t AliL3Track::Compare(const AliL3Track *track) const
{
  if(track->GetNHits() < GetNHits()) return 1;
  if(track->GetNHits() > GetNHits()) return -1;
  return 0;
}

AliL3Track::~AliL3Track()
{
  //Nothing to do
}

Double_t AliL3Track::GetP() const
{
  // Returns total momentum.  
  return fabs(GetPt())*sqrt(1. + GetTgl()*GetTgl());
}

Double_t AliL3Track::GetPseudoRapidity() const
{
  return 0.5 * log((GetP() + GetPz()) / (GetP() - GetPz()));
}

/*
Double_t AliL3Track::GetEta() const
{
  return GetPseudoRapidity();
}
*/

Double_t AliL3Track::GetRapidity() const
{
  Double_t m_pi = 0.13957;
  return 0.5 * log((m_pi + GetPz()) / (m_pi - GetPz()));
}

void AliL3Track::Rotate(Int_t slice,Bool_t tolocal)
{
  //Rotate track to global parameters
  //If flag tolocal is set, the track is rotated
  //to local coordinates.

  
  Float_t psi[1] = {GetPsi()};
  if(!tolocal)
    AliL3Transform::Local2GlobalAngle(psi,slice);
  else
    AliL3Transform::Global2LocalAngle(psi,slice);
  SetPsi(psi[0]);
  Float_t first[3];
  first[0] = GetFirstPointX();
  first[1] = GetFirstPointY();
  first[2] = GetFirstPointZ();
  if(!tolocal)
    AliL3Transform::Local2Global(first,slice);
  else
    AliL3Transform::Global2Local(first,slice,kTRUE);
  
  SetFirstPoint(first[0],first[1],first[2]);
  Float_t last[3];
  last[0] = GetLastPointX();
  last[1] = GetLastPointY();
  last[2] = GetLastPointZ();
  if(!tolocal)
    AliL3Transform::Local2Global(last,slice);
  else
    AliL3Transform::Global2Local(last,slice,kTRUE);
  SetLastPoint(last[0],last[1],last[2]);
  
  Float_t center[3] = {GetCenterX(),GetCenterY(),0};
  if(!tolocal)
    AliL3Transform::Local2Global(center,slice);
  else
    AliL3Transform::Global2Local(center,slice,kTRUE);
  SetCenterX(center[0]);
  SetCenterY(center[1]);
  
  if(!tolocal)
    fIsLocal=kFALSE;
  else
    fIsLocal=kTRUE;
}

void AliL3Track::CalculateHelix(){
  //Calculate Radius, CenterX and CenterY from Psi, X0, Y0
  //
  
  fRadius = fPt / (BFACT*AliL3Transform::GetBField());
  if(fRadius) fKappa = -fQ*1./fRadius;
  else fRadius = 999999;  //just zero
  Double_t trackPhi0 = fPsi + fQ *0.5 * pi;

  fCenterX = fFirstPoint[0] - fRadius *  cos(trackPhi0);
  fCenterY = fFirstPoint[1] - fRadius *  sin(trackPhi0);
}

Double_t AliL3Track::GetCrossingAngle(Int_t padrow) 
{
  //Calculate the crossing angle between track and given padrow.
  
  if(!IsLocal())
    {
      printf("Track is not given in local coordinates\n");
      return 0;
    }
  
  Float_t xyz[3];
  if(!GetCrossingPoint(padrow,xyz))
    printf("AliL3HoughTrack::GetCrossingPoint : Track does not cross line!!\n");
  
  //Take the dot product of the tangent vector of the track, and
  //vector perpendicular to the padrow.
  //In order to do this, we need the tangent vector to the track at the
  //point. This is done by rotating the radius vector by 90 degrees;
  //rotation matrix: (  0  1 )
  //                 ( -1  0 )
  
  Double_t tangent[2];
  tangent[0] = -1.*(xyz[1] - GetCenterY())/GetRadius();
  tangent[1] = (xyz[0] - GetCenterX())/GetRadius();
  
  Double_t perp_padrow[2] = {1,0}; //locally in slice

  Double_t cos_beta = fabs(tangent[0]*perp_padrow[0] + tangent[1]*perp_padrow[1]);
  return acos(cos_beta);
}

Bool_t AliL3Track::GetCrossingPoint(Int_t padrow,Float_t *xyz) 
{
  //Assumes the track is given in local coordinates

  if(!IsLocal())
    {
      printf("GetCrossingPoint: Track is given on global coordinates\n");
      return false;
    }
  
  Double_t xHit = AliL3Transform::Row2X(padrow);

  xyz[0] = xHit;
  Double_t aa = (xHit - GetCenterX())*(xHit - GetCenterX());
  Double_t r2 = GetRadius()*GetRadius();
  if(aa > r2)
    return false;

  Double_t aa2 = sqrt(r2 - aa);
  Double_t y1 = GetCenterY() + aa2;
  Double_t y2 = GetCenterY() - aa2;
  xyz[1] = y1;
  if(fabs(y2) < fabs(y1)) xyz[1] = y2;
  
  Double_t yHit = xyz[1];
  Double_t angle1 = atan2((yHit - GetCenterY()),(xHit - GetCenterX()));
  if(angle1 < 0) angle1 += 2.*AliL3Transform::Pi();
  Double_t angle2 = atan2((GetFirstPointY() - GetCenterY()),(GetFirstPointX() - GetCenterX()));
  if(angle2 < 0) angle2 += 2.*AliL3Transform::Pi();
  Double_t diff_angle = angle1 - angle2;
  diff_angle = fmod(diff_angle,2*AliL3Transform::Pi());
  if((GetCharge()*diff_angle) > 0) diff_angle = diff_angle - GetCharge()*2.*AliL3Transform::Pi();
  Double_t s_tot = fabs(diff_angle)*GetRadius();
  Double_t zHit = GetFirstPointZ() + s_tot*GetTgl();
  xyz[2] = zHit;
  
  return true;
}


Bool_t AliL3Track::CalculateReferencePoint(Double_t angle,Double_t radius){
  // Global coordinate: crossing point with y = ax+ b; a=tan(angle-AliL3Transform::Pi()/2);
  //
  const Double_t rr=radius;//132; //position of reference plane
  const Double_t xr = cos(angle) * rr;
  const Double_t yr = sin(angle) * rr;
  
  Double_t a = tan(angle-pi/2);
  Double_t b = yr - a * xr;

  Double_t pp=(fCenterX+a*fCenterY-a*b)/(1+pow(a,2));
  Double_t qq=(pow(fCenterX,2)+pow(fCenterY,2)-2*fCenterY*b+pow(b,2)-pow(fRadius,2))/(1+pow(a,2));

  Double_t racine = pp*pp-qq;
  if(racine<0) return IsPoint(kFALSE);      //no Point

  Double_t rootRacine = sqrt(racine);
  Double_t x0 = pp+rootRacine;
  Double_t x1 = pp-rootRacine;
  Double_t y0 = a*x0 + b;
  Double_t y1 = a*x1 + b;

  Double_t diff0 = sqrt(pow(x0-xr,2)+pow(y0-yr,2));
  Double_t diff1 = sqrt(pow(x1-xr,2)+pow(y1-yr,2));
 
  if(diff0<diff1){
    fPoint[0]=x0;
    fPoint[1]=y0;
  }
  else{
    fPoint[0]=x1;
    fPoint[1]=y1;
  }

  Double_t pointPhi0  = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
  Double_t trackPhi0  = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
  if(fabs(trackPhi0-pointPhi0)>pi){
    if(trackPhi0<pointPhi0) trackPhi0 += 2*pi;
    else                    pointPhi0 += 2*pi;
  }
  Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;
  fPoint[2]   = fFirstPoint[2] + stot * fTanl;

  fPointPsi = pointPhi0 - fQ * 0.5 * pi;
  if(fPointPsi<0.)  fPointPsi+= 2*pi;
  fPointPsi = fmod(fPointPsi, 2*pi);

  return IsPoint(kTRUE);
}

Bool_t AliL3Track::CalculateEdgePoint(Double_t angle){
  // Global coordinate: crossing point with y = ax; a=tan(angle);
  //
  Double_t rmin=80;  //min Radius of TPC
  Double_t rmax=260; //max Radius of TPC

  Double_t a = tan(angle);
  Double_t pp=(fCenterX+a*fCenterY)/(1+pow(a,2));
  Double_t qq=(pow(fCenterX,2)+pow(fCenterY,2)-pow(fRadius,2))/(1+pow(a,2));
  Double_t racine = pp*pp-qq;
  if(racine<0) return IsPoint(kFALSE);     //no Point
  Double_t rootRacine = sqrt(racine);
  Double_t x0 = pp+rootRacine;
  Double_t x1 = pp-rootRacine;
  Double_t y0 = a*x0;
  Double_t y1 = a*x1;

  Double_t r0 = sqrt(pow(x0,2)+pow(y0,2));
  Double_t r1 = sqrt(pow(x1,2)+pow(y1,2)); 
  //find the right crossing point:
  //inside the TPC modules
  Bool_t ok0 = kFALSE;
  Bool_t ok1 = kFALSE;

  if(r0>rmin&&r0<rmax){
    Double_t da=atan2(y0,x0);
    if(da<0) da+=2*pi;
    if(fabs(da-angle)<0.5)
      ok0 = kTRUE;
  }
  if(r1>rmin&&r1<rmax){
    Double_t da=atan2(y1,x1);
    if(da<0) da+=2*pi;
    if(fabs(da-angle)<0.5)
      ok1 = kTRUE;
  }
  if(!(ok0||ok1)) return IsPoint(kFALSE);   //no Point
  
  if(ok0&&ok1){
    Double_t diff0 = sqrt(pow(fFirstPoint[0]-x0,2)+pow(fFirstPoint[1]-y0,2));
    Double_t diff1 = sqrt(pow(fFirstPoint[0]-x1,2)+pow(fFirstPoint[1]-y1,2));
    if(diff0<diff1) ok1 = kFALSE; //use ok0
    else ok0 = kFALSE;            //use ok1
  }
  if(ok0){fPoint[0]=x0; fPoint[1]=y0;}
  else   {fPoint[0]=x1; fPoint[1]=y1;}

  Double_t pointPhi0  = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
  Double_t trackPhi0  = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
  if(fabs(trackPhi0-pointPhi0)>pi){
    if(trackPhi0<pointPhi0) trackPhi0 += 2*pi;
    else                    pointPhi0 += 2*pi;
  }
  Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;
  fPoint[2]   = fFirstPoint[2] + stot * fTanl;

  fPointPsi = pointPhi0 - fQ * 0.5 * pi;
  if(fPointPsi<0.)  fPointPsi+= 2*pi;
  fPointPsi = fmod(fPointPsi, 2*pi);

  return IsPoint(kTRUE);
}

Bool_t AliL3Track::CalculatePoint(Double_t xplane){
  // Local coordinate: crossing point with x plane
  //
  Double_t racine = pow(fRadius,2)-pow(xplane-fCenterX,2);
  if(racine<0) return IsPoint(kFALSE);
  Double_t rootRacine = sqrt(racine);

  Double_t y0 = fCenterY + rootRacine;
  Double_t y1 = fCenterY - rootRacine;
  //Double_t diff0 = sqrt(pow(fFirstPoint[0]-xplane)+pow(fFirstPoint[1]-y0));
  //Double_t diff1 = sqrt(pow(fFirstPoint[0]-xplane)+pow(fFirstPoint[1]-y1));
  Double_t diff0 = fabs(y0-fFirstPoint[1]);
  Double_t diff1 = fabs(y1-fFirstPoint[1]);

  fPoint[0]=xplane;
  if(diff0<diff1) fPoint[1]=y0;
  else            fPoint[1]=y1;

  Double_t pointPhi0  = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
  Double_t trackPhi0  = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
  if(fabs(trackPhi0-pointPhi0)>pi){
    if(trackPhi0<pointPhi0) trackPhi0 += 2*pi;
    else                    pointPhi0 += 2*pi;
  }
  Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;  
  fPoint[2]   = fFirstPoint[2] + stot * fTanl;

  fPointPsi = pointPhi0 - fQ * 0.5 * pi;
  if(fPointPsi<0.)  fPointPsi+= 2*pi;
  fPointPsi = fmod(fPointPsi, 2*pi);

  return IsPoint(kTRUE);
}

void AliL3Track::GetClosestPoint(AliL3Vertex *vertex,Double_t &closest_x,Double_t &closest_y,Double_t &closest_z)
{
  //Calculate the point of closest approach to the vertex
  
  
  Double_t xc = GetCenterX() - vertex->GetX();//Shift the center of curvature with respect to the vertex
  Double_t yc = GetCenterY() - vertex->GetY();
  
  Double_t dist_x1 = xc*(1 + GetRadius()/sqrt(xc*xc + yc*yc));
  Double_t dist_y1 = yc*(1 + GetRadius()/sqrt(xc*xc + yc*yc));
  Double_t distance1 = sqrt(dist_x1*dist_x1 + dist_y1*dist_y1);
  
  Double_t dist_x2 = xc*(1 - GetRadius()/sqrt(xc*xc + yc*yc));
  Double_t dist_y2 = yc*(1 - GetRadius()/sqrt(xc*xc + yc*yc));
  Double_t distance2 = sqrt(dist_x2*dist_x2 + dist_y2*dist_y2);
  
  //Choose the closest:
  if(distance1 < distance2)
    {
      closest_x = dist_x1 + vertex->GetX();
      closest_y = dist_y1 + vertex->GetY();
    }
  else
    {
      closest_x = dist_x2 + vertex->GetX();
      closest_y = dist_y2 + vertex->GetY();
    }
  
  //Get the z coordinate:
  Double_t angle1 = atan2((closest_y-GetCenterY()),(closest_x-GetCenterX()));
  if(angle1 < 0) angle1 = angle1 + 2*AliL3Transform::Pi();
 
  Double_t angle2 = atan2((GetFirstPointY()-GetCenterY()),(GetFirstPointX()-GetCenterX()));
  if(angle2 < 0) angle2 = angle2 + 2*AliL3Transform::Pi();
  
  Double_t diff_angle = angle1 - angle2;
  diff_angle = fmod(diff_angle,2*AliL3Transform::Pi());
  
  if((GetCharge()*diff_angle) < 0) diff_angle = diff_angle + GetCharge()*2*AliL3Transform::Pi();
  Double_t s_tot = fabs(diff_angle)*GetRadius();
  
  closest_z = GetFirstPointZ() - s_tot*GetTgl();
}
Commit	Line	Data
6d4f1901	1	//$Id$
6d4f1901	2
2d04dcbf	3	// Author: Anders Vestbo <mailto:vestbo$fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
2d04dcbf	4	//*-- Copyright &copy ASV
108615fc	5
108615fc	6
	7	#include "AliL3RootTypes.h"
	8
	9	#include "AliL3Logging.h"
	10	#include "AliL3Track.h"
0391971c	11	#include "AliL3Transform.h"
6d4f1901	12	#include "AliL3Vertex.h"
108615fc	13	#include <math.h>
108615fc	14
2d04dcbf	15	//_____________________________________________________________
	16	// AliL3Track
	17	//
	18	// Track base class
02cb36b2	19	//Begin_Html
	20	/*
	21	<img src="track_coordinates.gif">
	22	*/
	23	//End_Html
0391971c	24
108615fc	25	ClassImp(AliL3Track)
	26
	27	Float_t AliL3Track::BFACT = 0.0029980;
108615fc	28	Double_t AliL3Track::pi=3.14159265358979323846;
	29
	30	AliL3Track::AliL3Track()
	31	{
	32	//Constructor
	33
	34	fNHits = 0;
	35	fMCid = -1;
	36	fKappa=0;
	37	fRadius=0;
	38	fCenterX=0;
	39	fCenterY=0;
	40	ComesFromMainVertex(false);
	41	fQ = 0;
	42	fPhi0=0;
	43	fPsi=0;
	44	fR0=0;
	45	fTanl=0;
	46	fZ0=0;
	47	fPt=0;
	48	fLength=0;
	49	fIsLocal=true;
	50	fRowRange[0]=0;
	51	fRowRange[1]=0;
ae97a0b9	52	memset(fHitNumbers,0,176*sizeof(UInt_t));
108615fc	53	}
	54
	55	void AliL3Track::Set(AliL3Track *tpt){
	56
3a735e00	57	SetRowRange(tpt->GetFirstRow(),tpt->GetLastRow());
	58	SetPhi0(tpt->GetPhi0());
	59	SetKappa(tpt->GetKappa());
	60	SetNHits(tpt->GetNHits());
	61	SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
	62	SetLastPoint(tpt->GetLastPointX(),tpt->GetLastPointY(),tpt->GetLastPointZ());
	63	SetPt(tpt->GetPt());
	64	SetPsi(tpt->GetPsi());
	65	SetTgl(tpt->GetTgl());
	66	SetCharge(tpt->GetCharge());
	67	SetHits(tpt->GetNHits(),(UInt_t *)tpt->GetHitNumbers());
108615fc	68	}
108615fc	69
203925a9	70	Int_t AliL3Track::Compare(const AliL3Track *track) const
	71	{
	72	if(track->GetNHits() < GetNHits()) return 1;
	73	if(track->GetNHits() > GetNHits()) return -1;
	74	return 0;
	75	}
108615fc	76
	77	AliL3Track::~AliL3Track()
	78	{
203925a9	79	//Nothing to do
108615fc	80	}
	81
	82	Double_t AliL3Track::GetP() const
	83	{
203925a9	84	// Returns total momentum.
108615fc	85	return fabs(GetPt())sqrt(1. + GetTgl()GetTgl());
108615fc	86	}
	87
	88	Double_t AliL3Track::GetPseudoRapidity() const
	89	{
	90	return 0.5 * log((GetP() + GetPz()) / (GetP() - GetPz()));
	91	}
eeddc64d	92
203925a9	93	/*
108615fc	94	Double_t AliL3Track::GetEta() const
	95	{
	96	return GetPseudoRapidity();
	97	}
203925a9	98	*/
eeddc64d	99
108615fc	100	Double_t AliL3Track::GetRapidity() const
	101	{
	102	Double_t m_pi = 0.13957;
	103	return 0.5 * log((m_pi + GetPz()) / (m_pi - GetPz()));
	104	}
	105
203925a9	106	void AliL3Track::Rotate(Int_t slice,Bool_t tolocal)
0391971c	107	{
0391971c	108	//Rotate track to global parameters
203925a9	109	//If flag tolocal is set, the track is rotated
203925a9	110	//to local coordinates.
0391971c	111
0391971c	112
0391971c	113	Float_t psi[1] = {GetPsi()};
203925a9	114	if(!tolocal)
494fad94	115	AliL3Transform::Local2GlobalAngle(psi,slice);
203925a9	116	else
494fad94	117	AliL3Transform::Global2LocalAngle(psi,slice);
0391971c	118	SetPsi(psi[0]);
	119	Float_t first[3];
	120	first[0] = GetFirstPointX();
	121	first[1] = GetFirstPointY();
	122	first[2] = GetFirstPointZ();
203925a9	123	if(!tolocal)
494fad94	124	AliL3Transform::Local2Global(first,slice);
203925a9	125	else
494fad94	126	AliL3Transform::Global2Local(first,slice,kTRUE);
203925a9	127
0391971c	128	SetFirstPoint(first[0],first[1],first[2]);
	129	Float_t last[3];
	130	last[0] = GetLastPointX();
	131	last[1] = GetLastPointY();
	132	last[2] = GetLastPointZ();
203925a9	133	if(!tolocal)
494fad94	134	AliL3Transform::Local2Global(last,slice);
203925a9	135	else
494fad94	136	AliL3Transform::Global2Local(last,slice,kTRUE);
0391971c	137	SetLastPoint(last[0],last[1],last[2]);
203925a9	138
6d4f1901	139	Float_t center[3] = {GetCenterX(),GetCenterY(),0};
6d4f1901	140	if(!tolocal)
494fad94	141	AliL3Transform::Local2Global(center,slice);
6d4f1901	142	else
494fad94	143	AliL3Transform::Global2Local(center,slice,kTRUE);
6d4f1901	144	SetCenterX(center[0]);
	145	SetCenterY(center[1]);
	146
203925a9	147	if(!tolocal)
	148	fIsLocal=kFALSE;
	149	else
	150	fIsLocal=kTRUE;
0391971c	151	}
0391971c	152
108615fc	153	void AliL3Track::CalculateHelix(){
eeddc64d	154	//Calculate Radius, CenterX and CenterY from Psi, X0, Y0
108615fc	155	//
108615fc	156
ef79795d	157	fRadius = fPt / (BFACT*AliL3Transform::GetBField());
3ceb3fe1	158	if(fRadius) fKappa = -fQ*1./fRadius;
108615fc	159	else fRadius = 999999; //just zero
	160	Double_t trackPhi0 = fPsi + fQ 0.5 pi;
	161
	162	fCenterX = fFirstPoint[0] - fRadius * cos(trackPhi0);
	163	fCenterY = fFirstPoint[1] - fRadius * sin(trackPhi0);
	164	}
	165
2d04dcbf	166	Double_t AliL3Track::GetCrossingAngle(Int_t padrow)
0391971c	167	{
0391971c	168	//Calculate the crossing angle between track and given padrow.
2d04dcbf	169
0391971c	170	if(!IsLocal())
	171	{
	172	printf("Track is not given in local coordinates\n");
	173	return 0;
	174	}
2d04dcbf	175
0391971c	176	Float_t xyz[3];
	177	if(!GetCrossingPoint(padrow,xyz))
	178	printf("AliL3HoughTrack::GetCrossingPoint : Track does not cross line!!\n");
	179
	180	//Take the dot product of the tangent vector of the track, and
	181	//vector perpendicular to the padrow.
dab230b2	182	//In order to do this, we need the tangent vector to the track at the
	183	//point. This is done by rotating the radius vector by 90 degrees;
	184	//rotation matrix: ( 0 1 )
	185	// ( -1 0 )
0391971c	186
0391971c	187	Double_t tangent[2];
0391971c	188	tangent[0] = -1.*(xyz[1] - GetCenterY())/GetRadius();
dab230b2	189	tangent[1] = (xyz[0] - GetCenterX())/GetRadius();
dab230b2	190
0391971c	191	Double_t perp_padrow[2] = {1,0}; //locally in slice
	192
	193	Double_t cos_beta = fabs(tangent[0]perp_padrow[0] + tangent[1]perp_padrow[1]);
	194	return acos(cos_beta);
0391971c	195	}
0391971c	196
2d04dcbf	197	Bool_t AliL3Track::GetCrossingPoint(Int_t padrow,Float_t *xyz)
0391971c	198	{
	199	//Assumes the track is given in local coordinates
	200
0391971c	201	if(!IsLocal())
	202	{
	203	printf("GetCrossingPoint: Track is given on global coordinates\n");
	204	return false;
	205	}
	206
494fad94	207	Double_t xHit = AliL3Transform::Row2X(padrow);
0391971c	208
	209	xyz[0] = xHit;
	210	Double_t aa = (xHit - GetCenterX())*(xHit - GetCenterX());
	211	Double_t r2 = GetRadius()*GetRadius();
	212	if(aa > r2)
	213	return false;
	214
	215	Double_t aa2 = sqrt(r2 - aa);
	216	Double_t y1 = GetCenterY() + aa2;
	217	Double_t y2 = GetCenterY() - aa2;
	218	xyz[1] = y1;
	219	if(fabs(y2) < fabs(y1)) xyz[1] = y2;
	220
	221	Double_t yHit = xyz[1];
	222	Double_t angle1 = atan2((yHit - GetCenterY()),(xHit - GetCenterX()));
9ca67380	223	if(angle1 < 0) angle1 += 2.*AliL3Transform::Pi();
0391971c	224	Double_t angle2 = atan2((GetFirstPointY() - GetCenterY()),(GetFirstPointX() - GetCenterX()));
9ca67380	225	if(angle2 < 0) angle2 += 2.*AliL3Transform::Pi();
0391971c	226	Double_t diff_angle = angle1 - angle2;
9ca67380	227	diff_angle = fmod(diff_angle,2*AliL3Transform::Pi());
9ca67380	228	if((GetCharge()diff_angle) > 0) diff_angle = diff_angle - GetCharge()2.*AliL3Transform::Pi();
0391971c	229	Double_t s_tot = fabs(diff_angle)*GetRadius();
	230	Double_t zHit = GetFirstPointZ() + s_tot*GetTgl();
	231	xyz[2] = zHit;
	232
0391971c	233	return true;
	234	}
	235
	236
6d4f1901	237	Bool_t AliL3Track::CalculateReferencePoint(Double_t angle,Double_t radius){
9ca67380	238	// Global coordinate: crossing point with y = ax+ b; a=tan(angle-AliL3Transform::Pi()/2);
108615fc	239	//
eeddc64d	240	const Double_t rr=radius;//132; //position of reference plane
	241	const Double_t xr = cos(angle) * rr;
	242	const Double_t yr = sin(angle) * rr;
6d4f1901	243
108615fc	244	Double_t a = tan(angle-pi/2);
	245	Double_t b = yr - a * xr;
	246
	247	Double_t pp=(fCenterX+afCenterY-ab)/(1+pow(a,2));
	248	Double_t qq=(pow(fCenterX,2)+pow(fCenterY,2)-2fCenterYb+pow(b,2)-pow(fRadius,2))/(1+pow(a,2));
	249
	250	Double_t racine = pp*pp-qq;
	251	if(racine<0) return IsPoint(kFALSE); //no Point
	252
	253	Double_t rootRacine = sqrt(racine);
	254	Double_t x0 = pp+rootRacine;
	255	Double_t x1 = pp-rootRacine;
	256	Double_t y0 = a*x0 + b;
	257	Double_t y1 = a*x1 + b;
	258
	259	Double_t diff0 = sqrt(pow(x0-xr,2)+pow(y0-yr,2));
	260	Double_t diff1 = sqrt(pow(x1-xr,2)+pow(y1-yr,2));
	261
	262	if(diff0<diff1){
	263	fPoint[0]=x0;
	264	fPoint[1]=y0;
	265	}
	266	else{
	267	fPoint[0]=x1;
	268	fPoint[1]=y1;
	269	}
	270
	271	Double_t pointPhi0 = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
	272	Double_t trackPhi0 = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
	273	if(fabs(trackPhi0-pointPhi0)>pi){
	274	if(trackPhi0<pointPhi0) trackPhi0 += 2*pi;
	275	else pointPhi0 += 2*pi;
	276	}
	277	Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;
	278	fPoint[2] = fFirstPoint[2] + stot * fTanl;
	279
	280	fPointPsi = pointPhi0 - fQ * 0.5 * pi;
	281	if(fPointPsi<0.) fPointPsi+= 2*pi;
	282	fPointPsi = fmod(fPointPsi, 2*pi);
	283
	284	return IsPoint(kTRUE);
	285	}
	286
	287	Bool_t AliL3Track::CalculateEdgePoint(Double_t angle){
	288	// Global coordinate: crossing point with y = ax; a=tan(angle);
	289	//
	290	Double_t rmin=80; //min Radius of TPC
	291	Double_t rmax=260; //max Radius of TPC
	292
	293	Double_t a = tan(angle);
	294	Double_t pp=(fCenterX+a*fCenterY)/(1+pow(a,2));
	295	Double_t qq=(pow(fCenterX,2)+pow(fCenterY,2)-pow(fRadius,2))/(1+pow(a,2));
	296	Double_t racine = pp*pp-qq;
	297	if(racine<0) return IsPoint(kFALSE); //no Point
	298	Double_t rootRacine = sqrt(racine);
	299	Double_t x0 = pp+rootRacine;
	300	Double_t x1 = pp-rootRacine;
	301	Double_t y0 = a*x0;
	302	Double_t y1 = a*x1;
	303
	304	Double_t r0 = sqrt(pow(x0,2)+pow(y0,2));
	305	Double_t r1 = sqrt(pow(x1,2)+pow(y1,2));
	306	//find the right crossing point:
	307	//inside the TPC modules
308	Bool_t ok0 = kFALSE;
309	Bool_t ok1 = kFALSE;
472d9e24	310
108615fc	311	if(r0>rmin&&r0<rmax){
108615fc	312	Double_t da=atan2(y0,x0);
472d9e24	313	if(da<0) da+=2*pi;
108615fc	314	if(fabs(da-angle)<0.5)
	315	ok0 = kTRUE;
	316	}
	317	if(r1>rmin&&r1<rmax){
472d9e24	318	Double_t da=atan2(y1,x1);
472d9e24	319	if(da<0) da+=2*pi;
108615fc	320	if(fabs(da-angle)<0.5)
	321	ok1 = kTRUE;
	322	}
	323	if(!(ok0\|\|ok1)) return IsPoint(kFALSE); //no Point
	324
	325	if(ok0&&ok1){
	326	Double_t diff0 = sqrt(pow(fFirstPoint[0]-x0,2)+pow(fFirstPoint[1]-y0,2));
	327	Double_t diff1 = sqrt(pow(fFirstPoint[0]-x1,2)+pow(fFirstPoint[1]-y1,2));
	328	if(diff0<diff1) ok1 = kFALSE; //use ok0
	329	else ok0 = kFALSE; //use ok1
	330	}
	331	if(ok0){fPoint[0]=x0; fPoint[1]=y0;}
	332	else {fPoint[0]=x1; fPoint[1]=y1;}
	333
	334	Double_t pointPhi0 = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
	335	Double_t trackPhi0 = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
	336	if(fabs(trackPhi0-pointPhi0)>pi){
	337	if(trackPhi0<pointPhi0) trackPhi0 += 2*pi;
	338	else pointPhi0 += 2*pi;
	339	}
	340	Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;
	341	fPoint[2] = fFirstPoint[2] + stot * fTanl;
	342
	343	fPointPsi = pointPhi0 - fQ * 0.5 * pi;
	344	if(fPointPsi<0.) fPointPsi+= 2*pi;
	345	fPointPsi = fmod(fPointPsi, 2*pi);
	346
	347	return IsPoint(kTRUE);
	348	}
	349
	350	Bool_t AliL3Track::CalculatePoint(Double_t xplane){
	351	// Local coordinate: crossing point with x plane
	352	//
	353	Double_t racine = pow(fRadius,2)-pow(xplane-fCenterX,2);
	354	if(racine<0) return IsPoint(kFALSE);
	355	Double_t rootRacine = sqrt(racine);
	356
	357	Double_t y0 = fCenterY + rootRacine;
	358	Double_t y1 = fCenterY - rootRacine;
	359	//Double_t diff0 = sqrt(pow(fFirstPoint[0]-xplane)+pow(fFirstPoint[1]-y0));
	360	//Double_t diff1 = sqrt(pow(fFirstPoint[0]-xplane)+pow(fFirstPoint[1]-y1));
	361	Double_t diff0 = fabs(y0-fFirstPoint[1]);
	362	Double_t diff1 = fabs(y1-fFirstPoint[1]);
	363
	364	fPoint[0]=xplane;
	365	if(diff0<diff1) fPoint[1]=y0;
	366	else fPoint[1]=y1;
	367
	368	Double_t pointPhi0 = atan2(fPoint[1]-fCenterY,fPoint[0]-fCenterX);
	369	Double_t trackPhi0 = atan2(fFirstPoint[1]-fCenterY,fFirstPoint[0]-fCenterX);
	370	if(fabs(trackPhi0-pointPhi0)>pi){
	371	if(trackPhi0<pointPhi0) trackPhi0 += 2*pi;
	372	else pointPhi0 += 2*pi;
	373	}
	374	Double_t stot = -fQ * (pointPhi0-trackPhi0) * fRadius ;
	375	fPoint[2] = fFirstPoint[2] + stot * fTanl;
	376
	377	fPointPsi = pointPhi0 - fQ * 0.5 * pi;
	378	if(fPointPsi<0.) fPointPsi+= 2*pi;
	379	fPointPsi = fmod(fPointPsi, 2*pi);
	380
	381	return IsPoint(kTRUE);
	382	}
	383
6d4f1901	384	void AliL3Track::GetClosestPoint(AliL3Vertex *vertex,Double_t &closest_x,Double_t &closest_y,Double_t &closest_z)
	385	{
	386	//Calculate the point of closest approach to the vertex
	387
	388
	389	Double_t xc = GetCenterX() - vertex->GetX();//Shift the center of curvature with respect to the vertex
	390	Double_t yc = GetCenterY() - vertex->GetY();
	391
	392	Double_t dist_x1 = xc(1 + GetRadius()/sqrt(xcxc + yc*yc));
	393	Double_t dist_y1 = yc(1 + GetRadius()/sqrt(xcxc + yc*yc));
	394	Double_t distance1 = sqrt(dist_x1dist_x1 + dist_y1dist_y1);
	395
	396	Double_t dist_x2 = xc(1 - GetRadius()/sqrt(xcxc + yc*yc));
	397	Double_t dist_y2 = yc(1 - GetRadius()/sqrt(xcxc + yc*yc));
	398	Double_t distance2 = sqrt(dist_x2dist_x2 + dist_y2dist_y2);
	399
	400	//Choose the closest:
	401	if(distance1 < distance2)
	402	{
	403	closest_x = dist_x1 + vertex->GetX();
	404	closest_y = dist_y1 + vertex->GetY();
	405	}
	406	else
	407	{
	408	closest_x = dist_x2 + vertex->GetX();
	409	closest_y = dist_y2 + vertex->GetY();
	410	}
	411
	412	//Get the z coordinate:
	413	Double_t angle1 = atan2((closest_y-GetCenterY()),(closest_x-GetCenterX()));
9ca67380	414	if(angle1 < 0) angle1 = angle1 + 2*AliL3Transform::Pi();
6d4f1901	415
6d4f1901	416	Double_t angle2 = atan2((GetFirstPointY()-GetCenterY()),(GetFirstPointX()-GetCenterX()));
9ca67380	417	if(angle2 < 0) angle2 = angle2 + 2*AliL3Transform::Pi();
6d4f1901	418
6d4f1901	419	Double_t diff_angle = angle1 - angle2;
9ca67380	420	diff_angle = fmod(diff_angle,2*AliL3Transform::Pi());
6d4f1901	421
9ca67380	422	if((GetCharge()diff_angle) < 0) diff_angle = diff_angle + GetCharge()2*AliL3Transform::Pi();
6d4f1901	423	Double_t s_tot = fabs(diff_angle)*GetRadius();
	424
	425	closest_z = GetFirstPointZ() - s_tot*GetTgl();
	426	}