[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 "AliL3StandardIncludes.h"

#include "AliL3RootTypes.h"
#include "AliL3Logging.h"
#include "AliL3Track.h"
#include "AliL3Transform.h"
#include "AliL3Vertex.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,159*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());
#ifdef do_mc
  SetMCid(tpt->GetMCid());
#endif
}

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