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