[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 "AliL3Defs.h"
#include "AliL3Logging.h"
#include "AliL3Track.h"
#include "AliL3Transform.h"
#include "AliL3Vertex.h"
#include <math.h>

//_____________________________________________________________
// AliL3Track
//
// Track base class

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.

  AliL3Transform *transform = new AliL3Transform();
  
  Float_t psi[1] = {GetPsi()};
  if(!tolocal)
    transform->Local2GlobalAngle(psi,slice);
  else
    transform->Global2LocalAngle(psi,slice);
  SetPsi(psi[0]);
  Float_t first[3];
  first[0] = GetFirstPointX();
  first[1] = GetFirstPointY();
  first[2] = GetFirstPointZ();
  if(!tolocal)
    transform->Local2Global(first,slice);
  else
    transform->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)
    transform->Local2Global(last,slice);
  else
    transform->Global2Local(last,slice,kTRUE);
  SetLastPoint(last[0],last[1],last[2]);
  
  Float_t center[3] = {GetCenterX(),GetCenterY(),0};
  if(!tolocal)
    transform->Local2Global(center,slice);
  else
    transform->Global2Local(center,slice,kTRUE);
  SetCenterX(center[0]);
  SetCenterY(center[1]);
  
  if(!tolocal)
    fIsLocal=kFALSE;
  else
    fIsLocal=kTRUE;
  delete transform;
}

void AliL3Track::CalculateHelix(){
  //Calculate Radius, CenterX and Centery from Psi, X0, Y0
  //
  
  fRadius = fPt / (BFACT*BField);
  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.
  
  Double_t tangent[2];
  tangent[1] = (xyz[0] - GetCenterX())/GetRadius();
  tangent[0] = -1.*(xyz[1] - GetCenterY())/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

  AliL3Transform *transform = new AliL3Transform();
  
  if(!IsLocal())
    {
      printf("GetCrossingPoint: Track is given on global coordinates\n");
      return false;
    }
  
  Double_t xHit = transform->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.*Pi;
  Double_t angle2 = atan2((GetFirstPointY() - GetCenterY()),(GetFirstPointX() - GetCenterX()));
  if(angle2 < 0) angle2 += 2.*Pi;
  Double_t diff_angle = angle1 - angle2;
  diff_angle = fmod(diff_angle,2*Pi);
  if((GetCharge()*diff_angle) > 0) diff_angle = diff_angle - GetCharge()*2.*Pi;
  Double_t s_tot = fabs(diff_angle)*GetRadius();
  Double_t zHit = GetFirstPointZ() + s_tot*GetTgl();
  xyz[2] = zHit;
  
  delete transform;
  return true;
}


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