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

// @(#) $Id$

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

/** \class AliHLTTPCTrackMerger
<pre>
//_____________________________________________________________
// AliHLTTPCTrackMerger
//
// The HLTTPC track segment merger
//
</pre
*/

#include "AliHLTTPCLogging.h"
#include "AliHLTTPCTrackMerger.h"
#include "AliHLTTPCTrack.h"
#include "AliHLTTPCTrackSegmentData.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCTrackArray.h"

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

ClassImp(AliHLTTPCTrackMerger)

AliHLTTPCTrackMerger::AliHLTTPCTrackMerger(){
  //Default constructor
  Is2Global(kFALSE);
  fSlow = kFALSE;
  SetParameter();
  fRowMin = 0;
  fRowMax = 0;
}


AliHLTTPCTrackMerger::AliHLTTPCTrackMerger(Int_t nsubsectors) : AliHLTTPCMerger()
{
  //Constructor.
  InitMerger(nsubsectors);
  fNSubSector = nsubsectors;
  Is2Global(kFALSE);
  fSlow = kFALSE;
  SetParameter();
  fRowMin = new Int_t[nsubsectors];
  fRowMax = new Int_t[nsubsectors];
  
}

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

void AliHLTTPCTrackMerger::SetRows(Int_t *row){
  //Set the indeces of the first and last
  //TPC padrows
  //
  for(Int_t i=0;i<fNSubSector;i++){
    fRowMin[i]=*(row+(2*i));
    fRowMax[i]=*(row+(2*i+1));
  }
}

void AliHLTTPCTrackMerger::InitSector(Int_t slice,Int_t subsector){
  // 
  // Select Sector and subsector. The following FillTracks call will 
  // fill this subsector
  //
  fSlice = slice;
  fSubSector = subsector;
  fCurrentTracks = fSubSector;
}

void AliHLTTPCTrackMerger::SlowMerge(AliHLTTPCTrackArray *mergedtrack,AliHLTTPCTrackArray *tracksin,AliHLTTPCTrackArray *tracksout,Double_t xval){
  // 
  // Slow merging of two AliHLTTPCTrackArrays
  // at reference plane x=xval
  //
  void *ntuple=GetNtuple();
  const Int_t  kNOut=tracksout->GetNTracks();
  const Int_t  kNIn =tracksin->GetNTracks();
  const Int_t  kNMerged =mergedtrack->GetNTracks();
  AliHLTTPCTrack *tracks[2];
  Bool_t merge = kTRUE;
  while(merge){
    Int_t inmin=-1,outmin=-1;
    Double_t min=10;
    for(Int_t out=0;out<kNOut;out++){
    AliHLTTPCTrack *outertrack=tracksout->GetCheckedTrack(out);
    if(!outertrack) continue;
      for(Int_t in=0;in<kNIn;in++){
        AliHLTTPCTrack *innertrack=tracksin->GetCheckedTrack(in);
        if(!innertrack) continue;
        Double_t diff = TrackDiff(innertrack,outertrack);
        if(diff>=0&&diff<min){
          min=diff;
          inmin=in;
          outmin=out; 
        }
      } 
    }
    if(inmin>=0&&outmin>=0){
      AliHLTTPCTrack *outertrack=tracksout->GetTrack(outmin);
      AliHLTTPCTrack *innertrack=tracksin->GetTrack(inmin);
      tracks[0]=innertrack;
      tracks[1]=outertrack;
      SortTracks(tracks,2);
      MultiMerge(mergedtrack,tracks,2);
      outertrack->CalculatePoint(xval);
      innertrack->CalculatePoint(xval);
      PrintDiff(innertrack,outertrack);
      //FillNtuple(ntuple,innertrack,outertrack);
      tracksout->Remove(outmin);
      tracksin->Remove(inmin);
//      tracksout->Compress();
//      tracksin->Compress(); 
    }
    else merge = kFALSE;
  }
  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::SlowMerge","Result")
  <<AliHLTTPCLog::kDec<<"Merged Tracks: "
  <<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
  char name[256] = "ntuple_t.root";
  for(Int_t i=0;i<4;i++)
    if(tracksin==GetInTracks(i))
      sprintf(name,"ntuple_t_%d.root",i);
  WriteNtuple(name,ntuple);
}

void AliHLTTPCTrackMerger::SlowMerge(){
  fSlow = kTRUE;
  Merge();
}

void AliHLTTPCTrackMerger::InterMerge(){
  // 
  // Merging of the tracks
  // between readout patches
  //
  for(Int_t patch=0;patch< GetNIn();patch++){
    AliHLTTPCTrackArray * tracks = GetInTracks(patch);
    Double_t xval = AliHLTTPCTransform::Row2X((fRowMax[patch]+fRowMin[patch])/2);
    Int_t nrow= fRowMax[patch]-fRowMin[patch]+1;
    const Int_t  kNIn =tracks->GetNTracks();
    AliHLTTPCTrack *tr[2];
    for(Int_t in=0;in<kNIn;in++){
      AliHLTTPCTrack *t = tracks->GetCheckedTrack(in);
      if(t){
        t->CalculateHelix();
        t->CalculatePoint(xval);
      }
    }
    for(Int_t out=0;out<kNIn;out++){
    AliHLTTPCTrack *outertrack=tracks->GetCheckedTrack(out);
    if(!outertrack) continue;
      for(Int_t in=0;in<kNIn;in++){
        if(in==out) continue;
        AliHLTTPCTrack *innertrack=tracks->GetCheckedTrack(in);
        if(!innertrack) continue;
        if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;

        if(IsTrack(innertrack,outertrack)){
          tr[0]=innertrack;
          tr[1]=outertrack;
          SortTracks(tr,2);
          if(tr[0]->GetLastPointX()<tr[1]->GetFirstPointX()){
            MultiMerge(tracks,tr,2);
            tracks->Remove(out);
            tracks->Remove(in);
            break;
          }
        }
      }
    }
    Int_t nmerged = tracks->GetNTracks()-kNIn;
    LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::InterMerge","Result")
    <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
  }
}

void AliHLTTPCTrackMerger::Merge(){
  //Loop over tracks and pass them to the track merger.
  Double_t edge0 = AliHLTTPCTransform::Pi()/18;
  Double_t edge1 = AliHLTTPCTransform::TwoPi() - edge0;
  AliHLTTPCTrackArray *ttt = GetOutTracks();
  if(fNSubSector==1) {
    GetOutTracks()->AddTracks(GetInTracks(0)); 
    LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
    <<AliHLTTPCLog::kDec<<"Total Copied Tracks: "<<GetOutTracks()->GetNPresent()
    <<ENDLOG;
    return;
  }
  Int_t subsec = fNSubSector -2; 
  for(Int_t i=subsec;i>=0;i--){
    AliHLTTPCTrackArray *tout = GetOutTracks();
    if(i==subsec) tout = GetInTracks(subsec+1);
    AliHLTTPCTrackArray *tin = GetInTracks(i);
    Double_t xval = AliHLTTPCTransform::Row2X(fRowMax[i]);
    Double_t xmax = AliHLTTPCTransform::Row2X(fRowMax[i+1]);
    Double_t ymax = xval*tan(edge0);
    for(Int_t out=0;out<tout->GetNTracks();out++){
      AliHLTTPCTrack *outtrack=tout->GetCheckedTrack(out);
      if(!outtrack) continue;
      outtrack->CalculateHelix();
      outtrack->CalculatePoint(xval);
      if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
        if(outtrack->GetNHits()<10)
          tout->Remove(out);
      }
    }
//    tout->Compress();
    for(Int_t in=0;in<tin->GetNTracks();in++){
      AliHLTTPCTrack *intrack=(AliHLTTPCTrack*)tin->GetTrack(in);
      intrack->CalculateHelix();
      intrack->CalculatePoint(xval);
    }
    tin->QSort();
    tout->QSort();

    if(fSlow) SlowMerge(ttt,tin,tout,xval);
    else Merge(ttt,tin,tout);
    for(Int_t in=0;in<tin->GetNTracks();in++){
      AliHLTTPCTrack *intrack=(AliHLTTPCTrack*)tin->GetCheckedTrack(in);
      if(!intrack) continue;
      if(intrack->CalculateEdgePoint(edge0)){
        if(intrack->GetPointX()<xmax ){
          AddTrack(ttt,intrack);
          tin->Remove(in);
        }
      } 
      else if(intrack->CalculateEdgePoint(edge1)){
        if(intrack->GetPointX()<xmax ){
          AddTrack(ttt,intrack);
          tin->Remove(in);
        }
      }
    }
/*
    for(Int_t in=0;in<tin->GetNTracks();in++){
      AliHLTTPCTrack *intrack=(AliHLTTPCTrack*)tin->GetCheckedTrack(in);
      if(!intrack) continue;
      if(intrack->GetNHits()<10) continue;
      AddTrack(ttt,intrack);
      tin->Remove(in);
    }
*/
  } // end subsector loop
  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
  <<AliHLTTPCLog::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
  <<ENDLOG;
}

Int_t AliHLTTPCTrackMerger::Merge(AliHLTTPCTrackArray* mergedtrack,AliHLTTPCTrackArray *tracksin,AliHLTTPCTrackArray *tracksout){
  //Loop over tracks and pass them to the track merger.
  AliHLTTPCTrack *tracks[2];

  const Int_t  kNOut=tracksout->GetNTracks();
  const Int_t  kNIn =tracksin->GetNTracks();
  const Int_t  kNMerged =mergedtrack->GetNTracks();

  Bool_t *ismatchedin  = new Bool_t[kNIn];
  for(Int_t in =0;in<kNIn;in++)
    ismatchedin[in]=kFALSE;
  Bool_t *ismatchedout = new Bool_t[kNOut];
  for(Int_t out =0;out<kNOut;out++)
    ismatchedout[out] = kFALSE;
  for(Int_t out =0;out<kNOut;out++){
    AliHLTTPCTrack *outertrack=(AliHLTTPCTrack*)tracksout->GetCheckedTrack(out);
    if(!outertrack) continue;
    for(Int_t in =0;in<kNIn;in++){
      if(ismatchedin[in]) continue;
      AliHLTTPCTrack *innertrack=(AliHLTTPCTrack*)tracksin->GetCheckedTrack(in);
      if(!innertrack) continue;
      if(outertrack==innertrack) continue;
      if(outertrack->GetCharge()!=innertrack->GetCharge()) continue;
      if(IsTrack(innertrack,outertrack)){
        tracks[0]=innertrack; tracks[1]=outertrack; 
        SortTracks(tracks,2);  
        if(tracks[0]->GetLastPointX()<tracks[1]->GetFirstPointX()){
          MultiMerge(mergedtrack,tracks,2);
          tracksout->Remove(out);
          tracksin->Remove(in);
          ismatchedin[in]=kTRUE;
          ismatchedout[out]=kTRUE;
          break;
        }
      }
    }
  }

  Int_t nmerged = mergedtrack->GetNTracks()-kNMerged;
  LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
  <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
  delete[] ismatchedin;
  delete[] ismatchedout;
  return nmerged;
}
Commit	Line	Data
a6c02c85	1	// @(#) $Id$
	2
	3	// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>
	4	//*-- Copyright &copy ALICE HLT Group
	5
	6	/** \class AliHLTTPCTrackMerger
	7	<pre>
	8	//_____________________________________________________________
	9	// AliHLTTPCTrackMerger
	10	//
	11	// The HLTTPC track segment merger
	12	//
	13	</pre
	14	*/
	15
a6c02c85	16	#include "AliHLTTPCLogging.h"
	17	#include "AliHLTTPCTrackMerger.h"
	18	#include "AliHLTTPCTrack.h"
	19	#include "AliHLTTPCTrackSegmentData.h"
	20	#include "AliHLTTPCTransform.h"
	21	#include "AliHLTTPCTrackArray.h"
	22
	23	#if __GNUC__ >= 3
	24	using namespace std;
	25	#endif
	26
	27	ClassImp(AliHLTTPCTrackMerger)
	28
	29	AliHLTTPCTrackMerger::AliHLTTPCTrackMerger(){
	30	//Default constructor
	31	Is2Global(kFALSE);
	32	fSlow = kFALSE;
	33	SetParameter();
	34	fRowMin = 0;
	35	fRowMax = 0;
	36	}
	37
	38
	39	AliHLTTPCTrackMerger::AliHLTTPCTrackMerger(Int_t nsubsectors) : AliHLTTPCMerger()
	40	{
	41	//Constructor.
	42	InitMerger(nsubsectors);
	43	fNSubSector = nsubsectors;
	44	Is2Global(kFALSE);
	45	fSlow = kFALSE;
	46	SetParameter();
	47	fRowMin = new Int_t[nsubsectors];
	48	fRowMax = new Int_t[nsubsectors];
	49
	50	}
	51
	52	AliHLTTPCTrackMerger::~AliHLTTPCTrackMerger(){
	53	//Destructor
	54	}
	55
	56	void AliHLTTPCTrackMerger::SetRows(Int_t *row){
	57	//Set the indeces of the first and last
	58	//TPC padrows
	59	//
	60	for(Int_t i=0;i<fNSubSector;i++){
	61	fRowMin[i]=(row+(2i));
	62	fRowMax[i]=(row+(2i+1));
	63	}
	64	}
	65
	66	void AliHLTTPCTrackMerger::InitSector(Int_t slice,Int_t subsector){
	67	//
	68	// Select Sector and subsector. The following FillTracks call will
	69	// fill this subsector
	70	//
	71	fSlice = slice;
	72	fSubSector = subsector;
	73	fCurrentTracks = fSubSector;
	74	}
	75
	76	void AliHLTTPCTrackMerger::SlowMerge(AliHLTTPCTrackArray mergedtrack,AliHLTTPCTrackArray tracksin,AliHLTTPCTrackArray *tracksout,Double_t xval){
	77	//
	78	// Slow merging of two AliHLTTPCTrackArrays
	79	// at reference plane x=xval
80	//
81	void *ntuple=GetNtuple();
82	const Int_t kNOut=tracksout->GetNTracks();
83	const Int_t kNIn =tracksin->GetNTracks();
84	const Int_t kNMerged =mergedtrack->GetNTracks();
85	AliHLTTPCTrack *tracks[2];
86	Bool_t merge = kTRUE;
87	while(merge){
88	Int_t inmin=-1,outmin=-1;
89	Double_t min=10;
90	for(Int_t out=0;out<kNOut;out++){
91	AliHLTTPCTrack *outertrack=tracksout->GetCheckedTrack(out);
92	if(!outertrack) continue;
93	for(Int_t in=0;in<kNIn;in++){
94	AliHLTTPCTrack *innertrack=tracksin->GetCheckedTrack(in);
95	if(!innertrack) continue;
96	Double_t diff = TrackDiff(innertrack,outertrack);
97	if(diff>=0&&diff<min){
98	min=diff;
99	inmin=in;
100	outmin=out;
101	}
102	}
103	}
104	if(inmin>=0&&outmin>=0){
105	AliHLTTPCTrack *outertrack=tracksout->GetTrack(outmin);
106	AliHLTTPCTrack *innertrack=tracksin->GetTrack(inmin);
107	tracks[0]=innertrack;
108	tracks[1]=outertrack;
109	SortTracks(tracks,2);
110	MultiMerge(mergedtrack,tracks,2);
111	outertrack->CalculatePoint(xval);
112	innertrack->CalculatePoint(xval);
113	PrintDiff(innertrack,outertrack);
114	//FillNtuple(ntuple,innertrack,outertrack);
115	tracksout->Remove(outmin);
116	tracksin->Remove(inmin);
117	// tracksout->Compress();
118	// tracksin->Compress();
119	}
120	else merge = kFALSE;
121	}
122	LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::SlowMerge","Result")
123	<<AliHLTTPCLog::kDec<<"Merged Tracks: "
124	<<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
125	char name[256] = "ntuple_t.root";
126	for(Int_t i=0;i<4;i++)
127	if(tracksin==GetInTracks(i))
128	sprintf(name,"ntuple_t_%d.root",i);
129	WriteNtuple(name,ntuple);
130	}
131
132	void AliHLTTPCTrackMerger::SlowMerge(){
133	fSlow = kTRUE;
134	Merge();
135	}
136
137	void AliHLTTPCTrackMerger::InterMerge(){
138	//
139	// Merging of the tracks
140	// between readout patches
141	//
142	for(Int_t patch=0;patch< GetNIn();patch++){
143	AliHLTTPCTrackArray * tracks = GetInTracks(patch);
144	Double_t xval = AliHLTTPCTransform::Row2X((fRowMax[patch]+fRowMin[patch])/2);
145	Int_t nrow= fRowMax[patch]-fRowMin[patch]+1;
146	const Int_t kNIn =tracks->GetNTracks();
147	AliHLTTPCTrack *tr[2];
148	for(Int_t in=0;in<kNIn;in++){
149	AliHLTTPCTrack *t = tracks->GetCheckedTrack(in);
150	if(t){
151	t->CalculateHelix();
152	t->CalculatePoint(xval);
153	}
154	}
155	for(Int_t out=0;out<kNIn;out++){
156	AliHLTTPCTrack *outertrack=tracks->GetCheckedTrack(out);
157	if(!outertrack) continue;
158	for(Int_t in=0;in<kNIn;in++){
159	if(in==out) continue;
160	AliHLTTPCTrack *innertrack=tracks->GetCheckedTrack(in);
161	if(!innertrack) continue;
162	if(outertrack->GetNHits()+innertrack->GetNHits()>nrow) continue;
163
164	if(IsTrack(innertrack,outertrack)){
165	tr[0]=innertrack;
166	tr[1]=outertrack;
167	SortTracks(tr,2);
168	if(tr[0]->GetLastPointX()<tr[1]->GetFirstPointX()){
169	MultiMerge(tracks,tr,2);
170	tracks->Remove(out);
171	tracks->Remove(in);
172	break;
173	}
174	}
175	}
176	}
177	Int_t nmerged = tracks->GetNTracks()-kNIn;
178	LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::InterMerge","Result")
179	<<AliHLTTPCLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
180	}
181	}
182
183	void AliHLTTPCTrackMerger::Merge(){
184	//Loop over tracks and pass them to the track merger.
185	Double_t edge0 = AliHLTTPCTransform::Pi()/18;
186	Double_t edge1 = AliHLTTPCTransform::TwoPi() - edge0;
187	AliHLTTPCTrackArray *ttt = GetOutTracks();
188	if(fNSubSector==1) {
189	GetOutTracks()->AddTracks(GetInTracks(0));
190	LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
191	<<AliHLTTPCLog::kDec<<"Total Copied Tracks: "<<GetOutTracks()->GetNPresent()
192	<<ENDLOG;
193	return;
194	}
195	Int_t subsec = fNSubSector -2;
196	for(Int_t i=subsec;i>=0;i--){
197	AliHLTTPCTrackArray *tout = GetOutTracks();
198	if(i==subsec) tout = GetInTracks(subsec+1);
199	AliHLTTPCTrackArray *tin = GetInTracks(i);
200	Double_t xval = AliHLTTPCTransform::Row2X(fRowMax[i]);
201	Double_t xmax = AliHLTTPCTransform::Row2X(fRowMax[i+1]);
202	Double_t ymax = xval*tan(edge0);
203	for(Int_t out=0;out<tout->GetNTracks();out++){
204	AliHLTTPCTrack *outtrack=tout->GetCheckedTrack(out);
205	if(!outtrack) continue;
206	outtrack->CalculateHelix();
207	outtrack->CalculatePoint(xval);
208	if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
209	if(outtrack->GetNHits()<10)
210	tout->Remove(out);
211	}
212	}
213	// tout->Compress();
214	for(Int_t in=0;in<tin->GetNTracks();in++){
215	AliHLTTPCTrack intrack=(AliHLTTPCTrack)tin->GetTrack(in);
216	intrack->CalculateHelix();
217	intrack->CalculatePoint(xval);
218	}
219	tin->QSort();
220	tout->QSort();
221
222	if(fSlow) SlowMerge(ttt,tin,tout,xval);
223	else Merge(ttt,tin,tout);
224	for(Int_t in=0;in<tin->GetNTracks();in++){
225	AliHLTTPCTrack intrack=(AliHLTTPCTrack)tin->GetCheckedTrack(in);
226	if(!intrack) continue;
227	if(intrack->CalculateEdgePoint(edge0)){
228	if(intrack->GetPointX()<xmax ){
229	AddTrack(ttt,intrack);
230	tin->Remove(in);
231	}
232	}
233	else if(intrack->CalculateEdgePoint(edge1)){
234	if(intrack->GetPointX()<xmax ){
235	AddTrack(ttt,intrack);
236	tin->Remove(in);
237	}
238	}
239	}
240	/*
241	for(Int_t in=0;in<tin->GetNTracks();in++){
242	AliHLTTPCTrack intrack=(AliHLTTPCTrack)tin->GetCheckedTrack(in);
243	if(!intrack) continue;
244	if(intrack->GetNHits()<10) continue;
245	AddTrack(ttt,intrack);
246	tin->Remove(in);
247	}
248	*/
249	} // end subsector loop
250	LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
251	<<AliHLTTPCLog::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
252	<<ENDLOG;
253	}
254
255	Int_t AliHLTTPCTrackMerger::Merge(AliHLTTPCTrackArray* mergedtrack,AliHLTTPCTrackArray tracksin,AliHLTTPCTrackArray tracksout){
256	//Loop over tracks and pass them to the track merger.
257	AliHLTTPCTrack *tracks[2];
258
259	const Int_t kNOut=tracksout->GetNTracks();
260	const Int_t kNIn =tracksin->GetNTracks();
261	const Int_t kNMerged =mergedtrack->GetNTracks();
262
263	Bool_t *ismatchedin = new Bool_t[kNIn];
264	for(Int_t in =0;in<kNIn;in++)
265	ismatchedin[in]=kFALSE;
266	Bool_t *ismatchedout = new Bool_t[kNOut];
267	for(Int_t out =0;out<kNOut;out++)
268	ismatchedout[out] = kFALSE;
269	for(Int_t out =0;out<kNOut;out++){
270	AliHLTTPCTrack outertrack=(AliHLTTPCTrack)tracksout->GetCheckedTrack(out);
271	if(!outertrack) continue;
272	for(Int_t in =0;in<kNIn;in++){
273	if(ismatchedin[in]) continue;
274	AliHLTTPCTrack innertrack=(AliHLTTPCTrack)tracksin->GetCheckedTrack(in);
275	if(!innertrack) continue;
276	if(outertrack==innertrack) continue;
277	if(outertrack->GetCharge()!=innertrack->GetCharge()) continue;
278	if(IsTrack(innertrack,outertrack)){
279	tracks[0]=innertrack; tracks[1]=outertrack;
280	SortTracks(tracks,2);
281	if(tracks[0]->GetLastPointX()<tracks[1]->GetFirstPointX()){
282	MultiMerge(mergedtrack,tracks,2);
283	tracksout->Remove(out);
284	tracksin->Remove(in);
285	ismatchedin[in]=kTRUE;
286	ismatchedout[out]=kTRUE;
287	break;
288	}
289	}
290	}
291	}
292
293	Int_t nmerged = mergedtrack->GetNTracks()-kNMerged;
294	LOG(AliHLTTPCLog::kInformational,"AliHLTTPCTrackMerger::Merge","Result")
295	<<AliHLTTPCLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
296	delete[] ismatchedin;
297	delete[] ismatchedout;
298	return nmerged;
299	}
300
301