[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCGlobalMerger.cxx

// @(#) $Id$
// Original: AliHLTGlobalMerger.cxx,v 1.13 2005/06/14 10:55:21 cvetan 

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

#include "AliHLTTPCLogging.h"
#include "AliHLTTPCGlobalMerger.h"
#include "AliHLTTPCTrack.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCTrackArray.h"

/** \class AliHLTTPCGlobalMerger
<pre>
//_____________________________________________________________
// AliHLTTPCGlobalMerger
//
// The HLTTPC Slice merger
//
</pre>
*/

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

ClassImp(AliHLTTPCGlobalMerger)

AliHLTTPCGlobalMerger::AliHLTTPCGlobalMerger()
{
  //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;
}


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

void AliHLTTPCGlobalMerger::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 AliHLTTPCGlobalMerger::InitSlice(Int_t slice)
{
  // 
  // Select Sector The following FillTracks call will 
  // fill this Sector
  //
  fSlice = slice;
  fCurrentTracks = fSlice - fFirst; 
}

Double_t AliHLTTPCGlobalMerger::CheckTracks(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *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)
  AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
  Double_t dx[2],dy[2],dz[2];
  Double_t diff =-1;
  AliHLTTPCTrack *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();
  AliHLTTPCTransform::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();
  AliHLTTPCTransform::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 AliHLTTPCGlobalMerger::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();
  AliHLTTPCTrack *track[2];
  AliHLTTPCTrackArray *tout = GetOutTracks();
  if(fNSlices<2)
    {
      LOG(AliHLTTPCLog::kWarning,"AliHLTTPCGlobalMerger::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;
      AliHLTTPCTrackArray *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;
      AliHLTTPCTrackArray *ttt1=GetInTracks(slice2);
      //10 degrees -> the border of the slices in local coordinates
      Float_t angle = AliHLTTPCTransform::Pi()/18; 
      AliHLTTPCTransform::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++)
	{
	  AliHLTTPCTrack *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++)
	{
	  AliHLTTPCTrack *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++)
	    {
	      AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
	      if(!track0) continue;
	      if(!track0->IsPoint()) continue;
	      for(Int_t s1=0;s1<n1;s1++)
		{
		  AliHLTTPCTrack *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)
	    {
	      AliHLTTPCTrack *track0=ttt0->GetTrack(min0);
	      AliHLTTPCTrack *track1=ttt1->GetTrack(min1);
	      track[0] = track0;
	      track[1] = track1;
	      SortGlobalTracks(track,2);
	      track1->CalculateEdgePoint((angle+AliHLTTPCTransform::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(AliHLTTPCLog::kInformational,"AliHLTTPCGlobalMerger::SlowMerge","Result")
	<<AliHLTTPCLog::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
	<<angle<<ENDLOG;
    }
  Char_t fname[1024];
  sprintf(fname,"%s/merge_parameters.root",path);
  WriteNtuple(fname,ntuple);
}

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