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

// @(#) $Id$

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

#include "AliHLTStandardIncludes.h"

#include "AliHLTLogging.h"
#include "AliHLTTransform.h"
#include "AliHLTTrackArray.h"
#include "AliHLTHoughTrack.h"
#include "AliHLTHoughMerger.h"
#include "AliHLTHoughTransformer.h"

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

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

ClassImp(AliHLTHoughMerger)

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


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


AliHLTHoughMerger::~AliHLTHoughMerger()
{
  //dtor 
}

void AliHLTHoughMerger::FillTracks(AliHLTTrackArray *tracks,Int_t patch)
{
  //Fills tracks into merger
  if(tracks->GetNTracks()==0)
    LOG(AliHLTLog::kWarning,"AliHLTHoughMerger::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 AliHLTHoughMerger::SetParameters(Double_t maxkappa,Double_t maxpsi,Double_t maxphi0)
{
  //Set merger params
  fMaxKappa = maxkappa;
  fMaxPsi = maxpsi;
  fMaxPhi0 = maxphi0;
}

Bool_t AliHLTHoughMerger::IsTrack(AliHLTTrack *innertrack,AliHLTTrack *outertrack)
{
  //Check if the tracks can be merged, called by the track merger
  
  AliHLTHoughTrack *tr1 = (AliHLTHoughTrack*)innertrack;
  AliHLTHoughTrack *tr2 = (AliHLTHoughTrack*)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 AliHLTHoughMerger::AddTrack(AliHLTTrackArray *mergedtrack,AliHLTTrack *track)
{
  //Adds track to an already merged one
  AliHLTTrack *t[1];
  t[0] = track;
  MultiMerge(mergedtrack,t,1);
}

AliHLTTrack *AliHLTHoughMerger::MultiMerge(AliHLTTrackArray *mergedtrack,AliHLTTrack **tracks, Int_t ntrack)
{
  //Called by the track merger

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

  //Sum up the total weight:
  for(Int_t i=ntrack-1; i>=0; i--)
    weight += trs[i]->GetWeight();
  
  AliHLTHoughTrack *tpt=trs[0];//This is the innermost track
  AliHLTHoughTrack *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 (AliHLTTrack*)newtrack;

}

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

void AliHLTHoughMerger::Merge()
{
  //Merging of tracks
  Double_t edge0 = AliHLTTransform::Pi()/18;
  //Double_t edge1 = 2*PI - edge0;
  AliHLTTrackArray *ttt = GetOutTracks();
  
  Int_t subsec = GetNIn() - 2; 
  for(Int_t i=subsec;i>=0;i--){
    AliHLTTrackArray *tout = GetOutTracks();
    if(i==subsec) tout = GetInTracks(subsec+1);
    AliHLTTrackArray *tin = GetInTracks(i);
    Double_t xval = AliHLTTransform::Row2X(AliHLTTransform::GetLastRow(i));
    //Double_t xmax = AliHLTTransform::Row2X(AliHLTTransform::GetLastRow(i+1));
    Double_t ymax = xval*tan(edge0);
    for(Int_t out=0;out<tout->GetNTracks();out++){
      AliHLTTrack *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++){
      AliHLTTrack *intrack=(AliHLTTrack*)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++){
      AliHLTTrack *intrack=(AliHLTTrack*)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(AliHLTLog::kInformational,"AliHLTHoughMerger::Merge","Result")
    <<AliHLTLog::kDec<<"Total Merged Tracks: "<<GetOutTracks()->GetNPresent()
    <<ENDLOG;
}

Int_t AliHLTHoughMerger::Merge(AliHLTTrackArray* mergedtrack,AliHLTTrackArray *tracksin,AliHLTTrackArray *tracksout)
{
  //Merging of tracks  
  AliHLTTrack *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++){
    AliHLTTrack *outertrack=(AliHLTTrack*)tracksout->GetCheckedTrack(out);
    if(!outertrack) continue;
    for(Int_t in =0;in<kNIn;in++){
      if(ismatchedin[in]) continue;
      AliHLTTrack *innertrack=(AliHLTTrack*)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(AliHLTLog::kInformational,"AliHLTHoughMerger::Merge","Result")
    <<AliHLTLog::kDec<<"Merged Tracks: "<<nmerged<<ENDLOG;
  delete[] ismatchedin;
  delete[] ismatchedout;
  return nmerged;
}

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