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

// @(#) $Id$

// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
//*-- Copyright &copy ALICE HLT Group 

#include "AliHLTStandardIncludes.h"

#include "AliHLTLogging.h"
#include "AliHLTGlobalMerger.h"
#include "AliHLTTrack.h"
#include "AliHLTTransform.h"
#include "AliHLTTrackArray.h"

/** \class AliHLTGlobalMerger
<pre>
//_____________________________________________________________
// AliHLTGlobalMerger
//
// The L3 Slice merger
//
</pre>
*/

#if __GNUC__ >= 3
using namespace std;
#endif

ClassImp(AliHLTGlobalMerger)

AliHLTGlobalMerger::AliHLTGlobalMerger()
{
  //Default constructor. Use Setup to specify and setup the necessary parameters and arrays.
  Is2Global(kTRUE);
  SetParameter(0,0,0,0,0);
  fNSlices=0;
  fFirst=0;
  fLast=0;
}


AliHLTGlobalMerger::~AliHLTGlobalMerger()
{
  //Destructor
}

void AliHLTGlobalMerger::Setup(Int_t first,Int_t last)
{
  //Used to setup the arrays and everything
  
  fNSlices = last-first+1;
  fFirst = first;
  fLast = last;
  InitMerger(last-first+1);
}

void AliHLTGlobalMerger::InitSlice(Int_t slice)
{
  // 
  // Select Sector The following FillTracks call will 
  // fill this Sector
  //
  fSlice = slice;
  fCurrentTracks = fSlice - fFirst; 
}

Double_t AliHLTGlobalMerger::CheckTracks(AliHLTTrack *innertrack,AliHLTTrack *outertrack,Int_t slice)
{
  //Compare the tracks by propagating the outermost track to the last and first point plane
  //of the innermost track. This plane is defined by the padrow plane where these points
  //are.
  
  if(innertrack->GetCharge()!=outertrack->GetCharge()) return -1;
  
  Float_t angle = 0;//perpendicular to the padrowplane (in local system)
  AliHLTTransform::Local2GlobalAngle(&angle,slice);
  Double_t dx[2],dy[2],dz[2];
  Double_t diff =-1;
  AliHLTTrack *tracks[2];
  tracks[0] = innertrack;
  tracks[1] = outertrack;
  SortGlobalTracks(tracks,2);
  innertrack = tracks[0]; 
  outertrack = tracks[1];
  
  Float_t point[3];
  
  point[0]=innertrack->GetLastPointX();
  point[1]=innertrack->GetLastPointY();
  point[2]=innertrack->GetLastPointZ();
  AliHLTTransform::Global2LocHLT(point,slice);
  
  outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
  if(!outertrack->IsPoint()) return diff;
  dx[0] = fabs(outertrack->GetPointX()-innertrack->GetLastPointX());
  dy[0] = fabs(outertrack->GetPointY()-innertrack->GetLastPointY());
  dz[0] = fabs(outertrack->GetPointZ()-innertrack->GetLastPointZ());
  
  point[0]=innertrack->GetFirstPointX();
  point[1]=innertrack->GetFirstPointY();
  point[2]=innertrack->GetFirstPointZ();
  AliHLTTransform::Global2LocHLT(point,slice);
  
  outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
  if(!outertrack->IsPoint()) return diff;
  dx[1] = fabs(outertrack->GetPointX()-innertrack->GetFirstPointX());
  dy[1] = fabs(outertrack->GetPointY()-innertrack->GetFirstPointY());
  dz[1] = fabs(outertrack->GetPointZ()-innertrack->GetFirstPointZ());
  
  diff=0;//This was a tough bug to find....
  for(Int_t i=0; i<2; i++)
    diff += sqrt(dx[i]*dx[i] + dy[i]*dy[i] + dz[i]*dz[i]);
  return diff;
}

void AliHLTGlobalMerger::SlowMerge(Char_t *path)
{
  //Tuning of parameters. This matches _all_ tracks between two neighbouring
  //slices, and merges the ones which are closest in space. The difference
  //is written to a ntuppel, which can be used as a input for the SetParameters
  //when using normal Merge function.
  
  
  void* ntuple=GetNtuple();
  AliHLTTrack *track[2];
  AliHLTTrackArray *tout = GetOutTracks();
  if(fNSlices<2)
    {
      LOG(AliHLTLog::kWarning,"AliHLTGlobalMerger::SlowMerge","Slice Number")
	<<"Need more than one Slice!"<<ENDLOG;
      return;
    }
  
  for(Int_t i=0; i<fNSlices; i++)
    {
      //if(fNSlices!=18 && i+1 == fNSlices) continue; 
      Int_t slice = fFirst + i;
      AliHLTTrackArray *ttt0=GetInTracks(i);
      Int_t slice2 = i+1;
      //if(slice2==fNSlices) slice2 =0; 
      
      //Make sure slices are on the same side of the TPC
      if(slice2 == 18) slice2=0;
      else if(slice2 == 36) slice2=18;
      AliHLTTrackArray *ttt1=GetInTracks(slice2);
      //10 degrees -> the border of the slices in local coordinates
      Float_t angle = AliHLTTransform::Pi()/18; 
      AliHLTTransform::Local2GlobalAngle(&angle,slice);
      
      //In the two following cases, the angle is 2*pi, so set it back to 0 in order for
      //the calculation of crossing points to be correct.
      if(slice==17 || slice==35) 
	angle=0;
      if(i==0)
	ttt0->QSort();
      ttt1->QSort();
      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
	{
	  AliHLTTrack *track0=ttt0->GetCheckedTrack(s0);
	  if(!track0) continue;
	  track0->CalculateHelix();
	  track0->CalculateEdgePoint(angle);
	  //      if(track0->IsPoint()) AddTrack(tout,track0);
	}
      for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
	{
	  AliHLTTrack *track1=ttt1->GetCheckedTrack(s1);
	  if(!track1) continue;
	  track1->CalculateHelix();
	  track1->CalculateEdgePoint(angle);
	  //      if(track1->IsPoint())  AddTrack(tout,track1); 
	}
      Bool_t merge = kTRUE;
      while(merge)
	{
	  Int_t min0=-1,min1=-1;
	  Double_t min=5;
	  Int_t n0=ttt0->GetNTracks(),n1=ttt1->GetNTracks();
	  for(Int_t s0=0;s0<n0;s0++)
	    {
	      AliHLTTrack *track0=ttt0->GetCheckedTrack(s0);
	      if(!track0) continue;
	      if(!track0->IsPoint()) continue;
	      for(Int_t s1=0;s1<n1;s1++)
		{
		  AliHLTTrack *track1=ttt1->GetCheckedTrack(s1);
		  if(!track1) continue;
		  if(!track1->IsPoint()) continue;
		  
		  //Double_t diff = TrackDiff(track0,track1,angle);
		  Double_t diff = CheckTracks(track0,track1,slice);
		  //PrintDiff(track0,track1);
		  if(diff>=0&&diff<min)
		    {
		      min=diff;
		      min0=s0;
		      min1=s1;
		    }
		}
	    }
	  if(min0>=0&&min1>=0)
	    {
	      AliHLTTrack *track0=ttt0->GetTrack(min0);
	      AliHLTTrack *track1=ttt1->GetTrack(min1);
	      track[0] = track0;
	      track[1] = track1;
	      SortGlobalTracks(track,2);
	      track1->CalculateEdgePoint((angle+AliHLTTransform::Pi()/9));
	      if(track1->IsPoint())//Check if the track will cross the boundary of yet another slice.
		MultiMerge(ttt1,track,2);
	      else
		MultiMerge(tout,track,2); 
	      track0->CalculateReferencePoint(angle);
	      track1->CalculateReferencePoint(angle);
	      //PrintDiff(track0,track1);
	      FillNtuple(ntuple,track0,track1);
	      ttt0->Remove(min0);
	      ttt1->Remove(min1);
	      
	    }
	  else merge = kFALSE;
	}
      ttt0->Compress();
      ttt1->Compress();
      LOG(AliHLTLog::kInformational,"AliHLTGlobalMerger::SlowMerge","Result")
	<<AliHLTLog::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
	<<angle<<ENDLOG;
    }
  Char_t fname[1024];
  sprintf(fname,"%s/merge_parameters.root",path);
  WriteNtuple(fname,ntuple);
}

void AliHLTGlobalMerger::Merge()
{
  //Normal merging procedure. Matches tracks which are within limits
  //set by SetParameters. Parameters can be tuned by SlowMerge.
  
  AliHLTTrack *track[2];
  AliHLTTrackArray *tout = GetOutTracks();
  if(fNSlices<2)
    {
      LOG(AliHLTLog::kWarning,"AliHLTGlobalMerger::Merge","Slice Number")
	<<"Need more than one Slice!"<<ENDLOG;
      return;
    }
  for(Int_t i=0; i<fNSlices; i++)
    {
      //if(fNSlices!=18 && i+1 == fNSlices) continue; 
      Int_t slice = fFirst + i;
      AliHLTTrackArray *ttt0=GetInTracks(i);
      Int_t slice2 = i+1;
      //if(slice2==fNSlices) slice2 =0;
      
      //Make sure slices are on the same side of the TPC
      if(slice2 == 18) slice2=0;
      else if(slice2 == 36) slice2=18;
      AliHLTTrackArray *ttt1=GetInTracks(slice2);
      //10 degrees -> the border of the slices in local coordinates
      Float_t angle = AliHLTTransform::Pi()/18; 
      AliHLTTransform::Local2GlobalAngle(&angle,slice);
      
      //In the two following cases, the angle is 2*pi, so set it back to 0 in order for
      //the calculation of crossing points to be correct.
      if(slice==17 || slice==35)
	angle=0;
      if(i==0)
	ttt0->QSort();
      ttt1->QSort();
      Bool_t *ismatched0  = new Bool_t[ttt0->GetNTracks()];
      Bool_t *ismatched1  = new Bool_t[ttt1->GetNTracks()];
      Int_t n0=0,n1=0;
      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
	{
	  ismatched0[s0]=kFALSE;
	  AliHLTTrack *track0=ttt0->GetCheckedTrack(s0);
	  if(!track0) continue;
	  track0->CalculateHelix();
	  track0->CalculateEdgePoint(angle);
	  if(track0->IsPoint()) 
	    {
	      n0++;
	      track0->CalculateReferencePoint(angle);
	    }
	}
      for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
	{
	  ismatched1[s1]=kFALSE;
	  AliHLTTrack *track1=ttt1->GetCheckedTrack(s1);
	  if(!track1) continue;
	  track1->CalculateHelix();
	  track1->CalculateEdgePoint(angle);
	  if(track1->IsPoint()) 
	    {
	      n1++;
	      track1->CalculateReferencePoint(angle);
	    }
	}
      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
	{
	  if(ismatched0[s0]) continue;
	  AliHLTTrack *track0=ttt0->GetCheckedTrack(s0);
	  if(!track0) continue;
	  if(!track0->IsPoint()) continue;
	  for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
	    {
	      if(ismatched1[s1]) continue;
	      AliHLTTrack *track1=ttt1->GetCheckedTrack(s1);
	      if(!track1) continue;
	      if(!track1->IsPoint()) continue;
	      if(IsRTrack(track0,track1))
		{
		  track[0] = track0;
		  track[1] = track1;
		  SortGlobalTracks(track,2);
		  Double_t r0 = pow(track[0]->GetLastPointX(),2)+
		    pow(track[0]->GetLastPointY(),2);
		  Double_t r1 = pow(track[1]->GetFirstPointX(),2)+
		    pow(track[1]->GetFirstPointY(),2);
		  if(r0<r1)
		    {
		      MultiMerge(tout,track,2); 
		      ismatched0[s0]=kTRUE;
		      ismatched1[s1]=kTRUE;
		      ttt0->Remove(s0);
		      ttt1->Remove(s1);
		      break;
		      /*
			The track is merged, so we will _not_ look for more matches.
			Because there could easily be more matches, if a track is being
			split within the sector....
		      */
		    }
		}
	    }
	}
      LOG(AliHLTLog::kInformational,"AliHLTGlobalMerger::Merge","Result")
	<<AliHLTLog::kDec<<"slice0: "<<n0<<" slice1: "<<n1
	<<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
      delete [] ismatched0;
      delete [] ismatched1;
    }
}
Commit	Line	Data
3e87ef69	1	// @(#) $Id$
99cd2dbf	2
b661165c	3	// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
3e87ef69	4	//*-- Copyright &copy ALICE HLT Group
108615fc	5
4aa41877	6	#include "AliHLTStandardIncludes.h"
118c26c3	7
4aa41877	8	#include "AliHLTLogging.h"
	9	#include "AliHLTGlobalMerger.h"
	10	#include "AliHLTTrack.h"
	11	#include "AliHLTTransform.h"
	12	#include "AliHLTTrackArray.h"
b661165c	13
4aa41877	14	/** \class AliHLTGlobalMerger
3e87ef69	15	<pre>
108615fc	16	//_____________________________________________________________
4aa41877	17	// AliHLTGlobalMerger
108615fc	18	//
	19	// The L3 Slice merger
	20	//
3e87ef69	21	</pre>
3e87ef69	22	*/
108615fc	23
5929c18d	24	#if __GNUC__ >= 3
	25	using namespace std;
	26	#endif
	27
4aa41877	28	ClassImp(AliHLTGlobalMerger)
108615fc	29
4aa41877	30	AliHLTGlobalMerger::AliHLTGlobalMerger()
0a86fbb7	31	{
0a86fbb7	32	//Default constructor. Use Setup to specify and setup the necessary parameters and arrays.
108615fc	33	Is2Global(kTRUE);
0a86fbb7	34	SetParameter(0,0,0,0,0);
	35	fNSlices=0;
	36	fFirst=0;
	37	fLast=0;
108615fc	38	}
	39
	40
4aa41877	41	AliHLTGlobalMerger::~AliHLTGlobalMerger()
0a86fbb7	42	{
	43	//Destructor
	44	}
	45
4aa41877	46	void AliHLTGlobalMerger::Setup(Int_t first,Int_t last)
0a86fbb7	47	{
	48	//Used to setup the arrays and everything
	49
108615fc	50	fNSlices = last-first+1;
	51	fFirst = first;
	52	fLast = last;
0a86fbb7	53	InitMerger(last-first+1);
108615fc	54	}
108615fc	55
4aa41877	56	void AliHLTGlobalMerger::InitSlice(Int_t slice)
0a86fbb7	57	{
108615fc	58	//
	59	// Select Sector The following FillTracks call will
	60	// fill this Sector
	61	//
	62	fSlice = slice;
	63	fCurrentTracks = fSlice - fFirst;
	64	}
	65
4aa41877	66	Double_t AliHLTGlobalMerger::CheckTracks(AliHLTTrack innertrack,AliHLTTrack outertrack,Int_t slice)
99cd2dbf	67	{
	68	//Compare the tracks by propagating the outermost track to the last and first point plane
	69	//of the innermost track. This plane is defined by the padrow plane where these points
	70	//are.
	71
0a86fbb7	72	if(innertrack->GetCharge()!=outertrack->GetCharge()) return -1;
99cd2dbf	73
0a86fbb7	74	Float_t angle = 0;//perpendicular to the padrowplane (in local system)
4aa41877	75	AliHLTTransform::Local2GlobalAngle(&angle,slice);
99cd2dbf	76	Double_t dx[2],dy[2],dz[2];
99cd2dbf	77	Double_t diff =-1;
4aa41877	78	AliHLTTrack *tracks[2];
99cd2dbf	79	tracks[0] = innertrack;
	80	tracks[1] = outertrack;
	81	SortGlobalTracks(tracks,2);
	82	innertrack = tracks[0];
	83	outertrack = tracks[1];
	84
	85	Float_t point[3];
	86
	87	point[0]=innertrack->GetLastPointX();
	88	point[1]=innertrack->GetLastPointY();
	89	point[2]=innertrack->GetLastPointZ();
4aa41877	90	AliHLTTransform::Global2LocHLT(point,slice);
99cd2dbf	91
	92	outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
	93	if(!outertrack->IsPoint()) return diff;
	94	dx[0] = fabs(outertrack->GetPointX()-innertrack->GetLastPointX());
	95	dy[0] = fabs(outertrack->GetPointY()-innertrack->GetLastPointY());
	96	dz[0] = fabs(outertrack->GetPointZ()-innertrack->GetLastPointZ());
	97
	98	point[0]=innertrack->GetFirstPointX();
	99	point[1]=innertrack->GetFirstPointY();
	100	point[2]=innertrack->GetFirstPointZ();
4aa41877	101	AliHLTTransform::Global2LocHLT(point,slice);
99cd2dbf	102
	103	outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
	104	if(!outertrack->IsPoint()) return diff;
	105	dx[1] = fabs(outertrack->GetPointX()-innertrack->GetFirstPointX());
	106	dy[1] = fabs(outertrack->GetPointY()-innertrack->GetFirstPointY());
	107	dz[1] = fabs(outertrack->GetPointZ()-innertrack->GetFirstPointZ());
	108
0a86fbb7	109	diff=0;//This was a tough bug to find....
99cd2dbf	110	for(Int_t i=0; i<2; i++)
	111	diff += sqrt(dx[i]dx[i] + dy[i]dy[i] + dz[i]*dz[i]);
	112	return diff;
	113	}
	114
4aa41877	115	void AliHLTGlobalMerger::SlowMerge(Char_t *path)
0a86fbb7	116	{
	117	//Tuning of parameters. This matches _all_ tracks between two neighbouring
	118	//slices, and merges the ones which are closest in space. The difference
	119	//is written to a ntuppel, which can be used as a input for the SetParameters
	120	//when using normal Merge function.
	121
	122
108615fc	123	void* ntuple=GetNtuple();
4aa41877	124	AliHLTTrack *track[2];
4aa41877	125	AliHLTTrackArray *tout = GetOutTracks();
0a86fbb7	126	if(fNSlices<2)
0a86fbb7	127	{
4aa41877	128	LOG(AliHLTLog::kWarning,"AliHLTGlobalMerger::SlowMerge","Slice Number")
0a86fbb7	129	<<"Need more than one Slice!"<<ENDLOG;
0a86fbb7	130	return;
108615fc	131	}
0a86fbb7	132
	133	for(Int_t i=0; i<fNSlices; i++)
	134	{
	135	//if(fNSlices!=18 && i+1 == fNSlices) continue;
	136	Int_t slice = fFirst + i;
4aa41877	137	AliHLTTrackArray *ttt0=GetInTracks(i);
0a86fbb7	138	Int_t slice2 = i+1;
	139	//if(slice2==fNSlices) slice2 =0;
	140
	141	//Make sure slices are on the same side of the TPC
	142	if(slice2 == 18) slice2=0;
	143	else if(slice2 == 36) slice2=18;
4aa41877	144	AliHLTTrackArray *ttt1=GetInTracks(slice2);
5a31e9df	145	//10 degrees -> the border of the slices in local coordinates
4aa41877	146	Float_t angle = AliHLTTransform::Pi()/18;
4aa41877	147	AliHLTTransform::Local2GlobalAngle(&angle,slice);
0a86fbb7	148
	149	//In the two following cases, the angle is 2*pi, so set it back to 0 in order for
	150	//the calculation of crossing points to be correct.
	151	if(slice==17 \|\| slice==35)
	152	angle=0;
	153	if(i==0)
	154	ttt0->QSort();
	155	ttt1->QSort();
	156	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
	157	{
4aa41877	158	AliHLTTrack *track0=ttt0->GetCheckedTrack(s0);
0a86fbb7	159	if(!track0) continue;
	160	track0->CalculateHelix();
	161	track0->CalculateEdgePoint(angle);
	162	// if(track0->IsPoint()) AddTrack(tout,track0);
	163	}
	164	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
	165	{
4aa41877	166	AliHLTTrack *track1=ttt1->GetCheckedTrack(s1);
0a86fbb7	167	if(!track1) continue;
	168	track1->CalculateHelix();
	169	track1->CalculateEdgePoint(angle);
	170	// if(track1->IsPoint()) AddTrack(tout,track1);
	171	}
	172	Bool_t merge = kTRUE;
	173	while(merge)
	174	{
	175	Int_t min0=-1,min1=-1;
	176	Double_t min=5;
	177	Int_t n0=ttt0->GetNTracks(),n1=ttt1->GetNTracks();
	178	for(Int_t s0=0;s0<n0;s0++)
	179	{
4aa41877	180	AliHLTTrack *track0=ttt0->GetCheckedTrack(s0);
0a86fbb7	181	if(!track0) continue;
	182	if(!track0->IsPoint()) continue;
	183	for(Int_t s1=0;s1<n1;s1++)
	184	{
4aa41877	185	AliHLTTrack *track1=ttt1->GetCheckedTrack(s1);
0a86fbb7	186	if(!track1) continue;
	187	if(!track1->IsPoint()) continue;
	188
	189	//Double_t diff = TrackDiff(track0,track1,angle);
	190	Double_t diff = CheckTracks(track0,track1,slice);
	191	//PrintDiff(track0,track1);
	192	if(diff>=0&&diff<min)
	193	{
	194	min=diff;
	195	min0=s0;
	196	min1=s1;
	197	}
	198	}
	199	}
	200	if(min0>=0&&min1>=0)
	201	{
4aa41877	202	AliHLTTrack *track0=ttt0->GetTrack(min0);
4aa41877	203	AliHLTTrack *track1=ttt1->GetTrack(min1);
0a86fbb7	204	track[0] = track0;
	205	track[1] = track1;
	206	SortGlobalTracks(track,2);
4aa41877	207	track1->CalculateEdgePoint((angle+AliHLTTransform::Pi()/9));
0a86fbb7	208	if(track1->IsPoint())//Check if the track will cross the boundary of yet another slice.
	209	MultiMerge(ttt1,track,2);
	210	else
	211	MultiMerge(tout,track,2);
	212	track0->CalculateReferencePoint(angle);
	213	track1->CalculateReferencePoint(angle);
	214	//PrintDiff(track0,track1);
	215	FillNtuple(ntuple,track0,track1);
	216	ttt0->Remove(min0);
	217	ttt1->Remove(min1);
	218
	219	}
	220	else merge = kFALSE;
	221	}
	222	ttt0->Compress();
	223	ttt1->Compress();
4aa41877	224	LOG(AliHLTLog::kInformational,"AliHLTGlobalMerger::SlowMerge","Result")
4aa41877	225	<<AliHLTLog::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
0a86fbb7	226	<<angle<<ENDLOG;
108615fc	227	}
0a86fbb7	228	Char_t fname[1024];
	229	sprintf(fname,"%s/merge_parameters.root",path);
	230	WriteNtuple(fname,ntuple);
108615fc	231	}
108615fc	232
4aa41877	233	void AliHLTGlobalMerger::Merge()
0a86fbb7	234	{
	235	//Normal merging procedure. Matches tracks which are within limits
	236	//set by SetParameters. Parameters can be tuned by SlowMerge.
	237
4aa41877	238	AliHLTTrack *track[2];
4aa41877	239	AliHLTTrackArray *tout = GetOutTracks();
0a86fbb7	240	if(fNSlices<2)
0a86fbb7	241	{
4aa41877	242	LOG(AliHLTLog::kWarning,"AliHLTGlobalMerger::Merge","Slice Number")
0a86fbb7	243	<<"Need more than one Slice!"<<ENDLOG;
0a86fbb7	244	return;
108615fc	245	}
0a86fbb7	246	for(Int_t i=0; i<fNSlices; i++)
	247	{
	248	//if(fNSlices!=18 && i+1 == fNSlices) continue;
	249	Int_t slice = fFirst + i;
4aa41877	250	AliHLTTrackArray *ttt0=GetInTracks(i);
0a86fbb7	251	Int_t slice2 = i+1;
	252	//if(slice2==fNSlices) slice2 =0;
	253
	254	//Make sure slices are on the same side of the TPC
	255	if(slice2 == 18) slice2=0;
	256	else if(slice2 == 36) slice2=18;
4aa41877	257	AliHLTTrackArray *ttt1=GetInTracks(slice2);
5a31e9df	258	//10 degrees -> the border of the slices in local coordinates
4aa41877	259	Float_t angle = AliHLTTransform::Pi()/18;
4aa41877	260	AliHLTTransform::Local2GlobalAngle(&angle,slice);
0a86fbb7	261
	262	//In the two following cases, the angle is 2*pi, so set it back to 0 in order for
	263	//the calculation of crossing points to be correct.
	264	if(slice==17 \|\| slice==35)
	265	angle=0;
	266	if(i==0)
	267	ttt0->QSort();
	268	ttt1->QSort();
	269	Bool_t *ismatched0 = new Bool_t[ttt0->GetNTracks()];
	270	Bool_t *ismatched1 = new Bool_t[ttt1->GetNTracks()];
	271	Int_t n0=0,n1=0;
	272	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
	273	{
	274	ismatched0[s0]=kFALSE;
4aa41877	275	AliHLTTrack *track0=ttt0->GetCheckedTrack(s0);
0a86fbb7	276	if(!track0) continue;
	277	track0->CalculateHelix();
	278	track0->CalculateEdgePoint(angle);
	279	if(track0->IsPoint())
	280	{
	281	n0++;
	282	track0->CalculateReferencePoint(angle);
	283	}
	284	}
	285	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
	286	{
	287	ismatched1[s1]=kFALSE;
4aa41877	288	AliHLTTrack *track1=ttt1->GetCheckedTrack(s1);
0a86fbb7	289	if(!track1) continue;
	290	track1->CalculateHelix();
	291	track1->CalculateEdgePoint(angle);
	292	if(track1->IsPoint())
	293	{
	294	n1++;
	295	track1->CalculateReferencePoint(angle);
	296	}
	297	}
	298	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
	299	{
	300	if(ismatched0[s0]) continue;
4aa41877	301	AliHLTTrack *track0=ttt0->GetCheckedTrack(s0);
0a86fbb7	302	if(!track0) continue;
	303	if(!track0->IsPoint()) continue;
	304	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
	305	{
	306	if(ismatched1[s1]) continue;
4aa41877	307	AliHLTTrack *track1=ttt1->GetCheckedTrack(s1);
0a86fbb7	308	if(!track1) continue;
	309	if(!track1->IsPoint()) continue;
	310	if(IsRTrack(track0,track1))
	311	{
	312	track[0] = track0;
	313	track[1] = track1;
	314	SortGlobalTracks(track,2);
	315	Double_t r0 = pow(track[0]->GetLastPointX(),2)+
	316	pow(track[0]->GetLastPointY(),2);
	317	Double_t r1 = pow(track[1]->GetFirstPointX(),2)+
	318	pow(track[1]->GetFirstPointY(),2);
	319	if(r0<r1)
	320	{
	321	MultiMerge(tout,track,2);
	322	ismatched0[s0]=kTRUE;
	323	ismatched1[s1]=kTRUE;
	324	ttt0->Remove(s0);
	325	ttt1->Remove(s1);
	326	break;
	327	/*
	328	The track is merged, so we will _not_ look for more matches.
	329	Because there could easily be more matches, if a track is being
	330	split within the sector....
	331	*/
	332	}
	333	}
	334	}
	335	}
4aa41877	336	LOG(AliHLTLog::kInformational,"AliHLTGlobalMerger::Merge","Result")
4aa41877	337	<<AliHLTLog::kDec<<"slice0: "<<n0<<" slice1: "<<n1
0a86fbb7	338	<<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
	339	delete [] ismatched0;
	340	delete [] ismatched1;
108615fc	341	}
108615fc	342	}