[u/mrichter/AliRoot.git] / HLT / hough / AliL3HoughMerger.cxx

// @(#) $Id$

// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
//*-- Copyright &copy ALICE HLT Group

#include "AliL3StandardIncludes.h"

#include "AliL3Logging.h"
#include "AliL3Transform.h"
#include "AliL3TrackArray.h"
#include "AliL3HoughTrack.h"
#include "AliL3HoughMerger.h"
#include "AliL3HoughTransformer.h"

#if GCCVERSION == 3
using namespace std;
#endif

//_____________________________________________________________
// AliL3HoughMerger
//
// Patch merging class for Hough tracklets

ClassImp(AliL3HoughMerger)

  
AliL3HoughMerger::AliL3HoughMerger()
{
  //Default constructor
}


AliL3HoughMerger::AliL3HoughMerger(Int_t nsubsectors) 
{
  //Constructor
  InitMerger(nsubsectors,"AliL3HoughTrack");
  Is2Global(kFALSE);
  SetParameters(0.001,0.1,0.05);
}


AliL3HoughMerger::~AliL3HoughMerger()
{
 
}

void AliL3HoughMerger::FillTracks(AliL3TrackArray *tracks,Int_t patch)
{
  if(tracks->GetNTracks()==0)
    LOG(AliL3Log::kWarning,"AliL3HoughMerger::FillTracks","Track Array")
      <<"Adding empty track array"<<ENDLOG;
  
  GetInTracks(patch)->AddTracks(tracks,kFALSE);//Copy tracks
  printf("Filling %d tracks to merger\n",tracks->GetNTracks());
}

void AliL3HoughMerger::SetParameters(Double_t maxkappa,Double_t maxpsi,Double_t maxphi0)
{
  fMaxKappa = maxkappa;
  fMaxPsi = maxpsi;
  fMaxPhi0 = maxphi0;
}

Bool_t AliL3HoughMerger::IsTrack(AliL3Track *innertrack,AliL3Track *outertrack)
{
  //Check if the tracks can be merged, called by the track merger
  
  AliL3HoughTrack *tr1 = (AliL3HoughTrack*)innertrack;
  AliL3HoughTrack *tr2 = (AliL3HoughTrack*)outertrack;
  
  if( (!tr1->IsPoint()) || (!tr2->IsPoint()) )  return kFALSE; 
  if(abs(tr1->GetEtaIndex() - tr2->GetEtaIndex()) > 1) return kFALSE;
  if(tr1->GetCharge() != tr2->GetCharge()) return kFALSE;
  if(fabs(tr1->GetPhi0() - tr2->GetPhi0()) > fMaxPhi0) return kFALSE;
  if(fabs(tr1->GetKappa() - tr2->GetKappa()) > fMaxKappa) return kFALSE;
  
  /*
    if( (!tr1->IsPoint()) || (!tr2->IsPoint()) )  return kFALSE; 
    if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE;
    if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE;
    if(fabs(innertrack->GetKappa()-outertrack->GetKappa())   >fMaxKappa) return kFALSE;
    if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE;
    if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE;
  */
  
  return kTRUE;//Tracks could be merged
}

void AliL3HoughMerger::AddTrack(AliL3TrackArray *mergedtrack,AliL3Track *track)
{
  AliL3Track *t[1];
  t[0] = track;
  MultiMerge(mergedtrack,t,1);
}

AliL3Track *AliL3HoughMerger::MultiMerge(AliL3TrackArray *mergedtrack,AliL3Track **tracks, Int_t ntrack)
{
  //Called by the track merger

  AliL3HoughTrack *newtrack = (AliL3HoughTrack*)mergedtrack->NextTrack();
  AliL3HoughTrack **trs = (AliL3HoughTrack**)tracks;
  Int_t weight=0;

  //Sum up the total weight:
  for(Int_t i=ntrack-1; i>=0; i--)
    weight += trs[i]->GetWeight();
  
  AliL3HoughTrack *tpt=trs[0];//This is the innermost track
  AliL3HoughTrack *tpl=trs[ntrack-1];
  newtrack->SetTrackParameters(tpt->GetKappa(),tpt->GetPhi0(),weight);
  newtrack->SetEtaIndex(tpt->GetEtaIndex());
  newtrack->SetEta(tpt->GetEta());
  newtrack->SetPsi(tpt->GetPsi());
  newtrack->SetCenterX(tpt->GetCenterX());
  newtrack->SetCenterY(tpt->GetCenterY());
  newtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
  newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
  newtrack->SetCharge(tpt->GetCharge());
  newtrack->SetRowRange(tpt->GetFirstRow(),tpl->GetLastRow());
  
  return (AliL3Track*)newtrack;

}

void AliL3HoughMerger::MergePatches(Bool_t slow)
{
  //Merge tracks from across the patches.
  
  fSlow = slow;
  AliL3TrackArray *tracks;
  AliL3HoughTrack *track;
  for(Int_t i=0; i<GetNIn(); i++)
    {
      tracks = GetInTracks(i);
      for(Int_t j=0; j<tracks->GetNTracks(); j++)
	{
	  track = (AliL3HoughTrack*)tracks->GetCheckedTrack(j);
	  if(!track) continue;
	  track->UpdateToFirstRow();
	}
    }
  Merge();
  
}

void AliL3HoughMerger::Merge()
{
  Double_t edge0 = AliL3Transform::Pi()/18;
  //Double_t edge1 = 2*PI - edge0;
  AliL3TrackArray *ttt = GetOutTracks();
  
  Int_t subsec = GetNIn() - 2; 
  for(Int_t i=subsec;i>=0;i--){
    AliL3TrackArray *tout = GetOutTracks();
    if(i==subsec) tout = GetInTracks(subsec+1);
    AliL3TrackArray *tin = GetInTracks(i);
    Double_t xval = AliL3Transform::Row2X(AliL3Transform::GetLastRow(i));
    //Double_t xmax = AliL3Transform::Row2X(AliL3Transform::GetLastRow(i+1));
    Double_t ymax = xval*tan(edge0);
    for(Int_t out=0;out<tout->GetNTracks();out++){
      AliL3Track *outtrack=tout->GetCheckedTrack(out);
      if(!outtrack) continue;
      //outtrack->CalculateHelix();
      outtrack->CalculatePoint(xval);
      if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
	tout->Remove(out);
      }
    }
    //    tout->Compress();
    for(Int_t in=0;in<tin->GetNTracks();in++){
      AliL3Track *intrack=(AliL3Track*)tin->GetTrack(in);
      //intrack->CalculateHelix();
      intrack->CalculatePoint(xval);
    }
    tin->QSort();
    tout->QSort();

    if(fSlow) SlowMerge(ttt,tin,tout,xval);
    else Merge(ttt,tin,tout);

    /*
    //Add the tracks that cross the sector boundary:
    for(Int_t in=0;in<tin->GetNTracks();in++){
      AliL3Track *intrack=(AliL3Track*)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);
        }
      }
    }
    */
  } // end subsector loop
  LOG(AliL3Log::kInformational,"AliL3HoughMerger::Merge","Result")
    <<AliL3Log::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
    <<ENDLOG;
}

Int_t AliL3HoughMerger::Merge(AliL3TrackArray* mergedtrack,AliL3TrackArray *tracksin,AliL3TrackArray *tracksout)
{
  
  AliL3Track *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++){
    AliL3Track *outertrack=(AliL3Track*)tracksout->GetCheckedTrack(out);
    if(!outertrack) continue;
    for(Int_t in =0;in<kNIn;in++){
      if(ismatchedin[in]) continue;
      AliL3Track *innertrack=(AliL3Track*)tracksin->GetCheckedTrack(in);
      if(!innertrack) continue;
      if(outertrack==innertrack) continue;
      
      if(IsTrack(innertrack,outertrack)) //They can be merged
	{
	  tracks[0]=innertrack; tracks[1]=outertrack; 
	  SortTracks(tracks,2); //Sort the tracks according to minimum x-point
	  //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(AliL3Log::kInformational,"AliL3HoughMerger::Merge","Result")
    <<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
  delete[] ismatchedin;
  delete[] ismatchedout;
  return nmerged;
}

void AliL3HoughMerger::SlowMerge(AliL3TrackArray *mergedtrack,AliL3TrackArray *tracksin,AliL3TrackArray *tracksout,Double_t xval)
{
  void *ntuple=GetNtuple();
  const Int_t  kNOut=tracksout->GetNTracks();
  const Int_t  kNIn =tracksin->GetNTracks();
  const Int_t  kNMerged =mergedtrack->GetNTracks();
  AliL3Track *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++){
    AliL3Track *outertrack=tracksout->GetCheckedTrack(out);
    if(!outertrack) continue;
      for(Int_t in=0;in<kNIn;in++){
        AliL3Track *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){
      AliL3Track *outertrack=tracksout->GetTrack(outmin);
      AliL3Track *innertrack=tracksin->GetTrack(inmin);
      tracks[0]=innertrack;
      tracks[1]=outertrack;
      SortTracks(tracks,2);
      Print(tracks);
      MultiMerge(mergedtrack,tracks,2);
      outertrack->CalculatePoint(xval);
      innertrack->CalculatePoint(xval);
      FillNtuple(ntuple,innertrack,outertrack);
      tracksout->Remove(outmin);
      tracksin->Remove(inmin);
      //      tracksout->Compress();
      //      tracksin->Compress(); 
    }
    else merge = kFALSE;
  }
  LOG(AliL3Log::kInformational,"AliL3HoughMerger::SlowMerge","Result")
    <<AliL3Log::kDec<<"Merged Tracks: "
    <<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
  char name[256] = "ntuple_t.root";
  for(Int_t i=0;i<GetNIn();i++)
    if(tracksin==GetInTracks(i))
      sprintf(name,"ntuple_t_%d.root",i);
  WriteNtuple(name,ntuple);
}

void AliL3HoughMerger::Print(AliL3Track **tracks)
{
  AliL3HoughTrack *tr1 = (AliL3HoughTrack*)tracks[0];
  AliL3HoughTrack *tr2 = (AliL3HoughTrack*)tracks[1];
  Double_t kappadiff = fabs(tr1->GetKappa()-tr2->GetKappa());
  Double_t phi0diff = fabs(tr1->GetPhi0()-tr2->GetPhi0());
  cout << "---------Difference in merged tracks---------"<<endl;
  cout << "Kappa: "<<kappadiff<<" Phi0 : "<<phi0diff<<endl;
  
}
Commit	Line	Data
3e87ef69	1	// @(#) $Id$
3e87ef69	2
b1886074	3	// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
3e87ef69	4	//*-- Copyright &copy ALICE HLT Group
a1855560	5
e06900d5	6	#include "AliL3StandardIncludes.h"
e06900d5	7
a1855560	8	#include "AliL3Logging.h"
b1886074	9	#include "AliL3Transform.h"
a1855560	10	#include "AliL3TrackArray.h"
	11	#include "AliL3HoughTrack.h"
	12	#include "AliL3HoughMerger.h"
	13	#include "AliL3HoughTransformer.h"
	14
e06900d5	15	#if GCCVERSION == 3
	16	using namespace std;
	17	#endif
	18
b1886074	19	//_____________________________________________________________
	20	// AliL3HoughMerger
	21	//
	22	// Patch merging class for Hough tracklets
	23
a1855560	24	ClassImp(AliL3HoughMerger)
	25
	26
	27	AliL3HoughMerger::AliL3HoughMerger()
	28	{
	29	//Default constructor
a1855560	30	}
	31
	32
0a86fbb7	33	AliL3HoughMerger::AliL3HoughMerger(Int_t nsubsectors)
a1855560	34	{
a1855560	35	//Constructor
0a86fbb7	36	InitMerger(nsubsectors,"AliL3HoughTrack");
b1886074	37	Is2Global(kFALSE);
b1886074	38	SetParameters(0.001,0.1,0.05);
a1855560	39	}
	40
	41
	42	AliL3HoughMerger::~AliL3HoughMerger()
	43	{
b1886074	44
a1855560	45	}
a1855560	46
b1886074	47	void AliL3HoughMerger::FillTracks(AliL3TrackArray *tracks,Int_t patch)
a1855560	48	{
b1886074	49	if(tracks->GetNTracks()==0)
	50	LOG(AliL3Log::kWarning,"AliL3HoughMerger::FillTracks","Track Array")
	51	<<"Adding empty track array"<<ENDLOG;
	52
	53	GetInTracks(patch)->AddTracks(tracks,kFALSE);//Copy tracks
	54	printf("Filling %d tracks to merger\n",tracks->GetNTracks());
a1855560	55	}
a1855560	56
b1886074	57	void AliL3HoughMerger::SetParameters(Double_t maxkappa,Double_t maxpsi,Double_t maxphi0)
a1855560	58	{
b1886074	59	fMaxKappa = maxkappa;
	60	fMaxPsi = maxpsi;
	61	fMaxPhi0 = maxphi0;
a1855560	62	}
a1855560	63
b1886074	64	Bool_t AliL3HoughMerger::IsTrack(AliL3Track innertrack,AliL3Track outertrack)
a1855560	65	{
b1886074	66	//Check if the tracks can be merged, called by the track merger
	67
	68	AliL3HoughTrack tr1 = (AliL3HoughTrack)innertrack;
	69	AliL3HoughTrack tr2 = (AliL3HoughTrack)outertrack;
	70
	71	if( (!tr1->IsPoint()) \|\| (!tr2->IsPoint()) ) return kFALSE;
	72	if(abs(tr1->GetEtaIndex() - tr2->GetEtaIndex()) > 1) return kFALSE;
	73	if(tr1->GetCharge() != tr2->GetCharge()) return kFALSE;
	74	if(fabs(tr1->GetPhi0() - tr2->GetPhi0()) > fMaxPhi0) return kFALSE;
	75	if(fabs(tr1->GetKappa() - tr2->GetKappa()) > fMaxKappa) return kFALSE;
	76
	77	/*
	78	if( (!tr1->IsPoint()) \|\| (!tr2->IsPoint()) ) return kFALSE;
	79	if(fabs(innertrack->GetPointY()-outertrack->GetPointY()) >fMaxY) return kFALSE;
	80	if(fabs(innertrack->GetPointZ()-outertrack->GetPointZ()) >fMaxZ) return kFALSE;
	81	if(fabs(innertrack->GetKappa()-outertrack->GetKappa()) >fMaxKappa) return kFALSE;
	82	if(GetAngle(innertrack->GetPointPsi(),outertrack->GetPointPsi()) >fMaxPsi) return kFALSE;
	83	if(fabs(innertrack->GetTgl()-outertrack->GetTgl()) >fMaxTgl) return kFALSE;
	84	*/
	85
	86	return kTRUE;//Tracks could be merged
a1855560	87	}
a1855560	88
b1886074	89	void AliL3HoughMerger::AddTrack(AliL3TrackArray mergedtrack,AliL3Track track)
a1855560	90	{
b1886074	91	AliL3Track *t[1];
	92	t[0] = track;
	93	MultiMerge(mergedtrack,t,1);
	94	}
	95
	96	AliL3Track AliL3HoughMerger::MultiMerge(AliL3TrackArray mergedtrack,AliL3Track **tracks, Int_t ntrack)
	97	{
	98	//Called by the track merger
	99
	100	AliL3HoughTrack newtrack = (AliL3HoughTrack)mergedtrack->NextTrack();
	101	AliL3HoughTrack trs = (AliL3HoughTrack)tracks;
	102	Int_t weight=0;
	103
	104	//Sum up the total weight:
	105	for(Int_t i=ntrack-1; i>=0; i--)
	106	weight += trs[i]->GetWeight();
a1855560	107
b1886074	108	AliL3HoughTrack *tpt=trs[0];//This is the innermost track
	109	AliL3HoughTrack *tpl=trs[ntrack-1];
	110	newtrack->SetTrackParameters(tpt->GetKappa(),tpt->GetPhi0(),weight);
	111	newtrack->SetEtaIndex(tpt->GetEtaIndex());
	112	newtrack->SetEta(tpt->GetEta());
	113	newtrack->SetPsi(tpt->GetPsi());
	114	newtrack->SetCenterX(tpt->GetCenterX());
	115	newtrack->SetCenterY(tpt->GetCenterY());
	116	newtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
	117	newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
	118	newtrack->SetCharge(tpt->GetCharge());
	119	newtrack->SetRowRange(tpt->GetFirstRow(),tpl->GetLastRow());
a1855560	120
b1886074	121	return (AliL3Track*)newtrack;
b1886074	122
a1855560	123	}
a1855560	124
b1886074	125	void AliL3HoughMerger::MergePatches(Bool_t slow)
a1855560	126	{
b1886074	127	//Merge tracks from across the patches.
	128
	129	fSlow = slow;
	130	AliL3TrackArray *tracks;
	131	AliL3HoughTrack *track;
	132	for(Int_t i=0; i<GetNIn(); i++)
a1855560	133	{
b1886074	134	tracks = GetInTracks(i);
b1886074	135	for(Int_t j=0; j<tracks->GetNTracks(); j++)
a1855560	136	{
b1886074	137	track = (AliL3HoughTrack*)tracks->GetCheckedTrack(j);
	138	if(!track) continue;
	139	track->UpdateToFirstRow();
a1855560	140	}
a1855560	141	}
b1886074	142	Merge();
a1855560	143
b1886074	144	}
	145
	146	void AliL3HoughMerger::Merge()
	147	{
5a31e9df	148	Double_t edge0 = AliL3Transform::Pi()/18;
3e87ef69	149	//Double_t edge1 = 2*PI - edge0;
b1886074	150	AliL3TrackArray *ttt = GetOutTracks();
	151
	152	Int_t subsec = GetNIn() - 2;
	153	for(Int_t i=subsec;i>=0;i--){
	154	AliL3TrackArray *tout = GetOutTracks();
	155	if(i==subsec) tout = GetInTracks(subsec+1);
	156	AliL3TrackArray *tin = GetInTracks(i);
26abc209	157	Double_t xval = AliL3Transform::Row2X(AliL3Transform::GetLastRow(i));
3e87ef69	158	//Double_t xmax = AliL3Transform::Row2X(AliL3Transform::GetLastRow(i+1));
b1886074	159	Double_t ymax = xval*tan(edge0);
	160	for(Int_t out=0;out<tout->GetNTracks();out++){
	161	AliL3Track *outtrack=tout->GetCheckedTrack(out);
	162	if(!outtrack) continue;
	163	//outtrack->CalculateHelix();
	164	outtrack->CalculatePoint(xval);
	165	if(outtrack->IsPoint()&&fabs(outtrack->GetPointY())>ymax){
	166	tout->Remove(out);
	167	}
a1855560	168	}
b1886074	169	// tout->Compress();
	170	for(Int_t in=0;in<tin->GetNTracks();in++){
	171	AliL3Track intrack=(AliL3Track)tin->GetTrack(in);
	172	//intrack->CalculateHelix();
	173	intrack->CalculatePoint(xval);
	174	}
	175	tin->QSort();
	176	tout->QSort();
	177
	178	if(fSlow) SlowMerge(ttt,tin,tout,xval);
	179	else Merge(ttt,tin,tout);
	180
	181	/*
	182	//Add the tracks that cross the sector boundary:
	183	for(Int_t in=0;in<tin->GetNTracks();in++){
	184	AliL3Track intrack=(AliL3Track)tin->GetCheckedTrack(in);
	185	if(!intrack) continue;
	186	if(intrack->CalculateEdgePoint(edge0)){
	187	if(intrack->GetPointX()<xmax ){
	188	AddTrack(ttt,intrack);
	189	tin->Remove(in);
	190	}
	191	}
	192	else if(intrack->CalculateEdgePoint(edge1)){
	193	if(intrack->GetPointX()<xmax ){
	194	AddTrack(ttt,intrack);
	195	tin->Remove(in);
	196	}
	197	}
	198	}
	199	*/
	200	} // end subsector loop
	201	LOG(AliL3Log::kInformational,"AliL3HoughMerger::Merge","Result")
	202	<<AliL3Log::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
	203	<<ENDLOG;
a1855560	204	}
a1855560	205
b1886074	206	Int_t AliL3HoughMerger::Merge(AliL3TrackArray* mergedtrack,AliL3TrackArray tracksin,AliL3TrackArray tracksout)
a1855560	207	{
b1886074	208
	209	AliL3Track *tracks[2];
	210	const Int_t kNOut=tracksout->GetNTracks();
	211	const Int_t kNIn =tracksin->GetNTracks();
	212	const Int_t kNMerged =mergedtrack->GetNTracks();
	213
	214	Bool_t *ismatchedin = new Bool_t[kNIn];
	215	for(Int_t in =0;in<kNIn;in++)
	216	ismatchedin[in]=kFALSE;
	217	Bool_t *ismatchedout = new Bool_t[kNOut];
	218	for(Int_t out =0;out<kNOut;out++)
	219	ismatchedout[out] = kFALSE;
	220	for(Int_t out =0;out<kNOut;out++){
	221	AliL3Track outertrack=(AliL3Track)tracksout->GetCheckedTrack(out);
	222	if(!outertrack) continue;
	223	for(Int_t in =0;in<kNIn;in++){
	224	if(ismatchedin[in]) continue;
	225	AliL3Track innertrack=(AliL3Track)tracksin->GetCheckedTrack(in);
	226	if(!innertrack) continue;
	227	if(outertrack==innertrack) continue;
	228
	229	if(IsTrack(innertrack,outertrack)) //They can be merged
	230	{
	231	tracks[0]=innertrack; tracks[1]=outertrack;
	232	SortTracks(tracks,2); //Sort the tracks according to minimum x-point
	233	//if(tracks[0]->GetLastPointX()<tracks[1]->GetFirstPointX()){
	234	MultiMerge(mergedtrack,tracks,2);
	235	tracksout->Remove(out);
	236	tracksin->Remove(in);
	237	ismatchedin[in]=kTRUE;
	238	ismatchedout[out]=kTRUE;
	239	break;
	240	// }
	241	}
a1855560	242	}
b1886074	243	}
a1855560	244
b1886074	245	Int_t nmerged = mergedtrack->GetNTracks()-kNMerged;
	246	LOG(AliL3Log::kInformational,"AliL3HoughMerger::Merge","Result")
	247	<<AliL3Log::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
	248	delete[] ismatchedin;
	249	delete[] ismatchedout;
	250	return nmerged;
	251	}
	252
	253	void AliL3HoughMerger::SlowMerge(AliL3TrackArray mergedtrack,AliL3TrackArray tracksin,AliL3TrackArray *tracksout,Double_t xval)
	254	{
	255	void *ntuple=GetNtuple();
	256	const Int_t kNOut=tracksout->GetNTracks();
	257	const Int_t kNIn =tracksin->GetNTracks();
	258	const Int_t kNMerged =mergedtrack->GetNTracks();
	259	AliL3Track *tracks[2];
	260	Bool_t merge = kTRUE;
	261	while(merge){
	262	Int_t inmin=-1,outmin=-1;
	263	Double_t min=10;
	264	for(Int_t out=0;out<kNOut;out++){
	265	AliL3Track *outertrack=tracksout->GetCheckedTrack(out);
	266	if(!outertrack) continue;
	267	for(Int_t in=0;in<kNIn;in++){
	268	AliL3Track *innertrack=tracksin->GetCheckedTrack(in);
	269	if(!innertrack) continue;
	270	Double_t diff = TrackDiff(innertrack,outertrack);
	271	if(diff>=0&&diff<min){
	272	min=diff;
	273	inmin=in;
	274	outmin=out;
	275	}
	276	}
	277	}
	278	if(inmin>=0&&outmin>=0){
	279	AliL3Track *outertrack=tracksout->GetTrack(outmin);
	280	AliL3Track *innertrack=tracksin->GetTrack(inmin);
	281	tracks[0]=innertrack;
	282	tracks[1]=outertrack;
	283	SortTracks(tracks,2);
	284	Print(tracks);
	285	MultiMerge(mergedtrack,tracks,2);
	286	outertrack->CalculatePoint(xval);
	287	innertrack->CalculatePoint(xval);
	288	FillNtuple(ntuple,innertrack,outertrack);
	289	tracksout->Remove(outmin);
	290	tracksin->Remove(inmin);
	291	// tracksout->Compress();
	292	// tracksin->Compress();
	293	}
	294	else merge = kFALSE;
	295	}
	296	LOG(AliL3Log::kInformational,"AliL3HoughMerger::SlowMerge","Result")
	297	<<AliL3Log::kDec<<"Merged Tracks: "
	298	<<mergedtrack->GetNTracks()-kNMerged<<ENDLOG;
	299	char name[256] = "ntuple_t.root";
	300	for(Int_t i=0;i<GetNIn();i++)
	301	if(tracksin==GetInTracks(i))
	302	sprintf(name,"ntuple_t_%d.root",i);
	303	WriteNtuple(name,ntuple);
	304	}
	305
	306	void AliL3HoughMerger::Print(AliL3Track **tracks)
	307	{
	308	AliL3HoughTrack tr1 = (AliL3HoughTrack)tracks[0];
309	AliL3HoughTrack tr2 = (AliL3HoughTrack)tracks[1];
310	Double_t kappadiff = fabs(tr1->GetKappa()-tr2->GetKappa());
311	Double_t phi0diff = fabs(tr1->GetPhi0()-tr2->GetPhi0());
312	cout << "---------Difference in merged tracks---------"<<endl;
313	cout << "Kappa: "<<kappadiff<<" Phi0 : "<<phi0diff<<endl;
a1855560	314
a1855560	315	}