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