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

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

#include <stdlib.h>
#include <math.h>
#include <iostream.h>
#include "AliL3Logging.h"
#include "AliL3HoughTrack.h"
#include "AliL3HoughGlobalMerger.h"
#include "AliL3Track.h"
#include "AliL3Transform.h"
#include "AliL3TrackArray.h"

//_____________________________________________________________
// Merging Hough tracks across slices

ClassImp(AliL3HoughGlobalMerger)

AliL3HoughGlobalMerger::AliL3HoughGlobalMerger(){
  //Default constructor
  Is2Global(kTRUE);
  SetParameter(2,2,0.001,0.05,0.1);
}


AliL3HoughGlobalMerger::AliL3HoughGlobalMerger(Int_t first,Int_t last) : AliL3Merger(last-first+1,"AliL3HoughTrack")
{
  //Constructor.
  fNSlices = last-first+1;
  fFirst = first;
  fLast = last;
  Is2Global(kTRUE);
  SetParameter(2,2,0.001,0.05,0.1);
}

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


void AliL3HoughGlobalMerger::FillTracks(AliL3TrackArray *tracks,Int_t slice)
{
  fSlice = slice;
  fCurrentTracks = fSlice - fFirst; 
  if(tracks->GetNTracks()==0)
    LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::FillTracks","Track Array")
      <<AliL3Log::kDec<<"Adding empty track array in slice "<<fSlice<<ENDLOG;
  
  GetInTracks(fCurrentTracks)->AddTracks(tracks,kFALSE,fSlice);//Copy tracks, and rotate them to global coordinates
}

Bool_t AliL3HoughGlobalMerger::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;
  
  return kTRUE;
}

AliL3Track *AliL3HoughGlobalMerger::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 AliL3HoughGlobalMerger::SlowMerge(){
  void* ntuple=GetNtuple();
  AliL3Track *track[2];
  AliL3TrackArray *tout = GetOutTracks();
  if(fNSlices<2){
    LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::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; //full cicle == 18 slices
    Int_t slice = fFirst + i;
    AliL3TrackArray *ttt0=GetInTracks(i);
    Int_t slice2 = i+1;
    if(slice2==fNSlices) slice2 =0; 
    AliL3TrackArray *ttt1=GetInTracks(slice2);
    Float_t angle = PI/18.; //10 degrees -> the border of the slices
    fTransformer->Local2GlobalAngle(&angle,slice);
    if(i==0)
      ttt0->QSort();
    ttt1->QSort();
    for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
      AliL3Track *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++){
      AliL3Track *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=10;
      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
        AliL3Track *track0=ttt0->GetCheckedTrack(s0);
        if(!track0) continue;
        if(!track0->IsPoint()) continue;
        for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
          AliL3Track *track1=ttt1->GetCheckedTrack(s1);
          if(!track1) continue;
          if(!track1->IsPoint()) continue;
          Double_t diff = TrackDiff(track0,track1);
          if(diff>=0&&diff<min){
            min=diff;
            min0=s0;
            min1=s1;
          }
        }
      }
      if(min0>=0&&min1>=0){
        AliL3Track *track0=ttt0->GetTrack(min0);
        AliL3Track *track1=ttt1->GetTrack(min1);
        track[0] = track0;
        track[1] = track1;
        SortGlobalTracks(track,2);
        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(AliL3Log::kInformational,"AliL3HoughGlobalMerger::SlowMerge","Result")
  <<AliL3Log::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
  <<angle<<ENDLOG;
  }
  WriteNtuple("ntuple_s.root",ntuple);
}

void AliL3HoughGlobalMerger::Merge()
{
  AliL3Track *track[2];
  AliL3TrackArray *tout = GetOutTracks();
  if(fNSlices<2){
    LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::Merge","Slice Number")
      <<"Need more than one Slice!"<<ENDLOG;
    return;
  }
  Bool_t *ismatched0=0;
  Bool_t *ismatched1=0;
  for(Int_t i=0; i<fNSlices; i++)
    {
      if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
      Int_t slice = fFirst + i;
      AliL3TrackArray *ttt0=GetInTracks(i);
      Int_t slice2 = i+1;
      if(slice2==fNSlices) slice2 =0;
      AliL3TrackArray *ttt1=GetInTracks(slice2);
      Float_t angle = PI/18.; //10 degrees -> the border of the slices
      fTransformer->Local2GlobalAngle(&angle,slice);
      if(i==0)
	ttt0->QSort();
      ttt1->QSort();
      if(ismatched0) delete [] ismatched0;
      if(ismatched1) delete [] ismatched1;
      ismatched0  = new Bool_t[ttt0->GetNTracks()];
      ismatched1  = new Bool_t[ttt1->GetNTracks()];
      Int_t n0=0,n1=0;
      for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
	{
	  ismatched0[s0]=kFALSE;
	  AliL3Track *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;
	  AliL3Track *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++)
	{
	  AliL3Track *track0=ttt0->GetCheckedTrack(s0);
	  if(!track0) continue;
	  if(!track0->IsPoint()) continue;
	  for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
	    {
	      if(ismatched1[s1]) continue;
	      AliL3Track *track1=ttt1->GetCheckedTrack(s1);
	      if(!track1) continue;
	      if(!track1->IsPoint()) continue;
	      if(IsTrack(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);
		    }
		}
	    }
	}
      LOG(AliL3Log::kInformational,"AliL3HoughGlobalMerger::Merge","Result")
	<<AliL3Log::kDec<<"slice0: "<<n0<<" slice1: "<<n1
	<<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
    }
  if(ismatched0) delete [] ismatched0;
  if(ismatched1) delete [] ismatched1;
}
Commit	Line	Data
f0f02577	1	// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>
	2	//*-- Copyright &copy ASV
	3
95a00d93	4	#include <stdlib.h>
f0f02577	5	#include <math.h>
	6	#include <iostream.h>
	7	#include "AliL3Logging.h"
	8	#include "AliL3HoughTrack.h"
	9	#include "AliL3HoughGlobalMerger.h"
	10	#include "AliL3Track.h"
	11	#include "AliL3Transform.h"
	12	#include "AliL3TrackArray.h"
	13
	14	//_____________________________________________________________
	15	// Merging Hough tracks across slices
	16
	17	ClassImp(AliL3HoughGlobalMerger)
	18
	19	AliL3HoughGlobalMerger::AliL3HoughGlobalMerger(){
	20	//Default constructor
	21	Is2Global(kTRUE);
	22	SetParameter(2,2,0.001,0.05,0.1);
	23	}
	24
	25
	26	AliL3HoughGlobalMerger::AliL3HoughGlobalMerger(Int_t first,Int_t last) : AliL3Merger(last-first+1,"AliL3HoughTrack")
	27	{
	28	//Constructor.
	29	fNSlices = last-first+1;
	30	fFirst = first;
	31	fLast = last;
	32	Is2Global(kTRUE);
	33	SetParameter(2,2,0.001,0.05,0.1);
	34	}
	35
	36	AliL3HoughGlobalMerger::~AliL3HoughGlobalMerger(){
	37	//Destructor
	38	}
	39
	40
	41	void AliL3HoughGlobalMerger::FillTracks(AliL3TrackArray *tracks,Int_t slice)
	42	{
	43	fSlice = slice;
	44	fCurrentTracks = fSlice - fFirst;
	45	if(tracks->GetNTracks()==0)
	46	LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::FillTracks","Track Array")
	47	<<AliL3Log::kDec<<"Adding empty track array in slice "<<fSlice<<ENDLOG;
	48
	49	GetInTracks(fCurrentTracks)->AddTracks(tracks,kFALSE,fSlice);//Copy tracks, and rotate them to global coordinates
	50	}
	51
	52	Bool_t AliL3HoughGlobalMerger::IsTrack(AliL3Track innertrack,AliL3Track outertrack)
	53	{
	54	//Check if the tracks can be merged, called by the track merger
	55
	56	AliL3HoughTrack tr1 = (AliL3HoughTrack)innertrack;
	57	AliL3HoughTrack tr2 = (AliL3HoughTrack)outertrack;
	58
	59	if( (!tr1->IsPoint()) \|\| (!tr2->IsPoint()) ) return kFALSE;
	60	if(abs(tr1->GetEtaIndex() - tr2->GetEtaIndex()) > 1) return kFALSE;
	61	if(tr1->GetCharge() != tr2->GetCharge()) return kFALSE;
	62	if(fabs(tr1->GetPhi0() - tr2->GetPhi0()) > fMaxPhi0) return kFALSE;
	63	if(fabs(tr1->GetKappa() - tr2->GetKappa()) > fMaxKappa) return kFALSE;
	64
	65	return kTRUE;
	66	}
	67
	68	AliL3Track AliL3HoughGlobalMerger::MultiMerge(AliL3TrackArray mergedtrack,AliL3Track **tracks, Int_t ntrack)
69	{
70	//Called by the track merger
71
72	AliL3HoughTrack newtrack = (AliL3HoughTrack)mergedtrack->NextTrack();
73	AliL3HoughTrack trs = (AliL3HoughTrack)tracks;
74	Int_t weight=0;
75
76	//Sum up the total weight:
77	for(Int_t i=ntrack-1; i>=0; i--)
78	weight += trs[i]->GetWeight();
79
80	AliL3HoughTrack *tpt=trs[0];//This is the innermost track
81	AliL3HoughTrack *tpl=trs[ntrack-1];
82	newtrack->SetTrackParameters(tpt->GetKappa(),tpt->GetPhi0(),weight);
83	newtrack->SetEtaIndex(tpt->GetEtaIndex());
84	newtrack->SetEta(tpt->GetEta());
85	newtrack->SetPsi(tpt->GetPsi());
86	newtrack->SetCenterX(tpt->GetCenterX());
87	newtrack->SetCenterY(tpt->GetCenterY());
88	newtrack->SetFirstPoint(tpt->GetFirstPointX(),tpt->GetFirstPointY(),tpt->GetFirstPointZ());
89	newtrack->SetLastPoint(tpl->GetLastPointX(),tpl->GetLastPointY(),tpl->GetLastPointZ());
90	newtrack->SetCharge(tpt->GetCharge());
91	newtrack->SetRowRange(tpt->GetFirstRow(),tpl->GetLastRow());
92
93	return (AliL3Track*)newtrack;
94
95	}
96
97	void AliL3HoughGlobalMerger::SlowMerge(){
98	void* ntuple=GetNtuple();
99	AliL3Track *track[2];
100	AliL3TrackArray *tout = GetOutTracks();
101	if(fNSlices<2){
102	LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::SlowMerge","Slice Number")
103	<<"Need more than one Slice!"<<ENDLOG;
104	return;
105	}
106	for(Int_t i=0; i<fNSlices; i++){
107	if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
108	Int_t slice = fFirst + i;
109	AliL3TrackArray *ttt0=GetInTracks(i);
110	Int_t slice2 = i+1;
111	if(slice2==fNSlices) slice2 =0;
112	AliL3TrackArray *ttt1=GetInTracks(slice2);
113	Float_t angle = PI/18.; //10 degrees -> the border of the slices
114	fTransformer->Local2GlobalAngle(&angle,slice);
115	if(i==0)
116	ttt0->QSort();
117	ttt1->QSort();
118	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
119	AliL3Track *track0=ttt0->GetCheckedTrack(s0);
120	if(!track0) continue;
121	track0->CalculateHelix();
122	track0->CalculateEdgePoint(angle);
123	// if(track0->IsPoint()) AddTrack(tout,track0);
124	}
125	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
126	AliL3Track *track1=ttt1->GetCheckedTrack(s1);
127	if(!track1) continue;
128	track1->CalculateHelix();
129	track1->CalculateEdgePoint(angle);
130	// if(track1->IsPoint()) AddTrack(tout,track1);
131	}
132	Bool_t merge = kTRUE;
133	while(merge){
134	Int_t min0=-1,min1=-1;
135	Double_t min=10;
136	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){
137	AliL3Track *track0=ttt0->GetCheckedTrack(s0);
138	if(!track0) continue;
139	if(!track0->IsPoint()) continue;
140	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){
141	AliL3Track *track1=ttt1->GetCheckedTrack(s1);
142	if(!track1) continue;
143	if(!track1->IsPoint()) continue;
144	Double_t diff = TrackDiff(track0,track1);
145	if(diff>=0&&diff<min){
146	min=diff;
147	min0=s0;
148	min1=s1;
149	}
150	}
151	}
152	if(min0>=0&&min1>=0){
153	AliL3Track *track0=ttt0->GetTrack(min0);
154	AliL3Track *track1=ttt1->GetTrack(min1);
155	track[0] = track0;
156	track[1] = track1;
157	SortGlobalTracks(track,2);
158	MultiMerge(tout,track,2);
159	track0->CalculateReferencePoint(angle);
160	track1->CalculateReferencePoint(angle);
161	PrintDiff(track0,track1);
162	FillNtuple(ntuple,track0,track1);
163	ttt0->Remove(min0);
164	ttt1->Remove(min1);
165	}
166	else merge = kFALSE;
167	}
168	ttt0->Compress();
169	ttt1->Compress();
170	LOG(AliL3Log::kInformational,"AliL3HoughGlobalMerger::SlowMerge","Result")
171	<<AliL3Log::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
172	<<angle<<ENDLOG;
173	}
174	WriteNtuple("ntuple_s.root",ntuple);
175	}
176
177	void AliL3HoughGlobalMerger::Merge()
178	{
179	AliL3Track *track[2];
180	AliL3TrackArray *tout = GetOutTracks();
181	if(fNSlices<2){
182	LOG(AliL3Log::kWarning,"AliL3HoughGlobalMerger::Merge","Slice Number")
183	<<"Need more than one Slice!"<<ENDLOG;
184	return;
185	}
186	Bool_t *ismatched0=0;
187	Bool_t *ismatched1=0;
188	for(Int_t i=0; i<fNSlices; i++)
189	{
190	if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices
191	Int_t slice = fFirst + i;
192	AliL3TrackArray *ttt0=GetInTracks(i);
193	Int_t slice2 = i+1;
194	if(slice2==fNSlices) slice2 =0;
195	AliL3TrackArray *ttt1=GetInTracks(slice2);
196	Float_t angle = PI/18.; //10 degrees -> the border of the slices
197	fTransformer->Local2GlobalAngle(&angle,slice);
198	if(i==0)
199	ttt0->QSort();
200	ttt1->QSort();
201	if(ismatched0) delete [] ismatched0;
202	if(ismatched1) delete [] ismatched1;
203	ismatched0 = new Bool_t[ttt0->GetNTracks()];
204	ismatched1 = new Bool_t[ttt1->GetNTracks()];
205	Int_t n0=0,n1=0;
206	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
207	{
208	ismatched0[s0]=kFALSE;
209	AliL3Track *track0=ttt0->GetCheckedTrack(s0);
210	if(!track0) continue;
211	track0->CalculateHelix();
212	track0->CalculateEdgePoint(angle);
213	if(track0->IsPoint()) {n0++;track0->CalculateReferencePoint(angle);
214	}
215	}
216	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
217	{
218	ismatched1[s1]=kFALSE;
219	AliL3Track *track1=ttt1->GetCheckedTrack(s1);
220	if(!track1) continue;
221	track1->CalculateHelix();
222	track1->CalculateEdgePoint(angle);
223	if(track1->IsPoint()) {n1++;track1->CalculateReferencePoint(angle);
224	}
225	}
226	for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
227	{
228	AliL3Track *track0=ttt0->GetCheckedTrack(s0);
229	if(!track0) continue;
230	if(!track0->IsPoint()) continue;
231	for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
232	{
233	if(ismatched1[s1]) continue;
234	AliL3Track *track1=ttt1->GetCheckedTrack(s1);
235	if(!track1) continue;
236	if(!track1->IsPoint()) continue;
237	if(IsTrack(track0,track1))
238	{
239	track[0] = track0;
240	track[1] = track1;
241	SortGlobalTracks(track,2);
242	Double_t r0 = pow(track[0]->GetLastPointX(),2) + pow(track[0]->GetLastPointY(),2);
243	Double_t r1 = pow(track[1]->GetFirstPointX(),2) + pow(track[1]->GetFirstPointY(),2);
244	if(r0<r1)
245	{
246	MultiMerge(tout,track,2);
247	ismatched0[s0]=kTRUE;
248	ismatched1[s1]=kTRUE;
249	ttt0->Remove(s0);
250	ttt1->Remove(s1);
251	}
252	}
253	}
254	}
255	LOG(AliL3Log::kInformational,"AliL3HoughGlobalMerger::Merge","Result")
256	<<AliL3Log::kDec<<"slice0: "<<n0<<" slice1: "<<n1
257	<<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
258	}
259	if(ismatched0) delete [] ismatched0;
260	if(ismatched1) delete [] ismatched1;
261	}