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