]>
Commit | Line | Data |
---|---|---|
99cd2dbf | 1 | //$Id$ |
2 | ||
b661165c | 3 | // Author: Uli Frankenfeld <mailto:franken@fi.uib.no> |
4 | //*-- Copyright © Uli | |
108615fc | 5 | |
6 | #include <math.h> | |
7 | #include <iostream.h> | |
8 | #include "AliL3Logging.h" | |
9 | #include "AliL3GlobalMerger.h" | |
10 | #include "AliL3Track.h" | |
11 | #include "AliL3Transform.h" | |
12 | #include "AliL3TrackArray.h" | |
b661165c | 13 | |
108615fc | 14 | //_____________________________________________________________ |
b661165c | 15 | // AliL3GlobalMerger |
108615fc | 16 | // |
17 | // The L3 Slice merger | |
18 | // | |
19 | ||
20 | ClassImp(AliL3GlobalMerger) | |
21 | ||
22 | AliL3GlobalMerger::AliL3GlobalMerger(){ | |
23 | //Default constructor | |
24 | Is2Global(kTRUE); | |
25 | SetParameter(2,2,0.001,0.05,0.1); | |
26 | } | |
27 | ||
28 | ||
29 | AliL3GlobalMerger::AliL3GlobalMerger(Int_t first,Int_t last):AliL3Merger(last-first+1){ | |
30 | //Constructor. | |
31 | fNSlices = last-first+1; | |
32 | fFirst = first; | |
33 | fLast = last; | |
34 | Is2Global(kTRUE); | |
3ea3b9f9 | 35 | SetParameter(2,2,0.001,0.05,0.1); |
108615fc | 36 | } |
37 | ||
38 | AliL3GlobalMerger::~AliL3GlobalMerger(){ | |
39 | //Destructor | |
40 | } | |
41 | ||
42 | void AliL3GlobalMerger::InitSlice(Int_t slice){ | |
43 | // | |
44 | // Select Sector The following FillTracks call will | |
45 | // fill this Sector | |
46 | // | |
47 | fSlice = slice; | |
48 | fCurrentTracks = fSlice - fFirst; | |
49 | } | |
50 | ||
99cd2dbf | 51 | Double_t AliL3GlobalMerger::CheckTracks(AliL3Track *innertrack,AliL3Track *outertrack,Int_t slice) |
52 | { | |
53 | //Compare the tracks by propagating the outermost track to the last and first point plane | |
54 | //of the innermost track. This plane is defined by the padrow plane where these points | |
55 | //are. | |
56 | ||
57 | ||
58 | Float_t angle = PI/36;//5 degrees = perpendicular to padrowplane (in local system) | |
59 | fTransformer->Local2GlobalAngle(&angle,slice); | |
60 | Double_t dx[2],dy[2],dz[2]; | |
61 | Double_t diff =-1; | |
62 | AliL3Track *tracks[2]; | |
63 | tracks[0] = innertrack; | |
64 | tracks[1] = outertrack; | |
65 | SortGlobalTracks(tracks,2); | |
66 | innertrack = tracks[0]; | |
67 | outertrack = tracks[1]; | |
68 | ||
69 | Float_t point[3]; | |
70 | ||
71 | point[0]=innertrack->GetLastPointX(); | |
72 | point[1]=innertrack->GetLastPointY(); | |
73 | point[2]=innertrack->GetLastPointZ(); | |
74 | fTransformer->Global2Local(point,slice,kTRUE); | |
75 | ||
76 | outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane | |
77 | if(!outertrack->IsPoint()) return diff; | |
78 | dx[0] = fabs(outertrack->GetPointX()-innertrack->GetLastPointX()); | |
79 | dy[0] = fabs(outertrack->GetPointY()-innertrack->GetLastPointY()); | |
80 | dz[0] = fabs(outertrack->GetPointZ()-innertrack->GetLastPointZ()); | |
81 | ||
82 | point[0]=innertrack->GetFirstPointX(); | |
83 | point[1]=innertrack->GetFirstPointY(); | |
84 | point[2]=innertrack->GetFirstPointZ(); | |
85 | fTransformer->Global2Local(point,slice,kTRUE); | |
86 | ||
87 | outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane | |
88 | if(!outertrack->IsPoint()) return diff; | |
89 | dx[1] = fabs(outertrack->GetPointX()-innertrack->GetFirstPointX()); | |
90 | dy[1] = fabs(outertrack->GetPointY()-innertrack->GetFirstPointY()); | |
91 | dz[1] = fabs(outertrack->GetPointZ()-innertrack->GetFirstPointZ()); | |
92 | ||
93 | for(Int_t i=0; i<2; i++) | |
94 | diff += sqrt(dx[i]*dx[i] + dy[i]*dy[i] + dz[i]*dz[i]); | |
95 | return diff; | |
96 | } | |
97 | ||
108615fc | 98 | void AliL3GlobalMerger::SlowMerge(){ |
99 | void* ntuple=GetNtuple(); | |
100 | AliL3Track *track[2]; | |
101 | AliL3TrackArray *tout = GetOutTracks(); | |
102 | if(fNSlices<2){ | |
103 | LOG(AliL3Log::kWarning,"AliL3GlobalMerger::SlowMerge","Slice Number") | |
104 | <<"Need more than one Slice!"<<ENDLOG; | |
105 | return; | |
106 | } | |
3ea3b9f9 | 107 | for(Int_t i=0; i<fNSlices; i++){ |
108 | if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices | |
108615fc | 109 | Int_t slice = fFirst + i; |
110 | AliL3TrackArray *ttt0=GetInTracks(i); | |
3ea3b9f9 | 111 | Int_t slice2 = i+1; |
112 | if(slice2==fNSlices) slice2 =0; | |
113 | AliL3TrackArray *ttt1=GetInTracks(slice2); | |
108615fc | 114 | Float_t angle = PI/18.; //10 degrees -> the border of the slices |
115 | fTransformer->Local2GlobalAngle(&angle,slice); | |
3ea3b9f9 | 116 | if(i==0) |
117 | ttt0->QSort(); | |
118 | ttt1->QSort(); | |
108615fc | 119 | for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){ |
3ea3b9f9 | 120 | AliL3Track *track0=ttt0->GetCheckedTrack(s0); |
121 | if(!track0) continue; | |
108615fc | 122 | track0->CalculateHelix(); |
123 | track0->CalculateEdgePoint(angle); | |
99cd2dbf | 124 | // if(track0->IsPoint()) AddTrack(tout,track0); |
108615fc | 125 | } |
108615fc | 126 | for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){ |
3ea3b9f9 | 127 | AliL3Track *track1=ttt1->GetCheckedTrack(s1); |
128 | if(!track1) continue; | |
108615fc | 129 | track1->CalculateHelix(); |
130 | track1->CalculateEdgePoint(angle); | |
99cd2dbf | 131 | // if(track1->IsPoint()) AddTrack(tout,track1); |
108615fc | 132 | } |
108615fc | 133 | Bool_t merge = kTRUE; |
134 | while(merge){ | |
135 | Int_t min0=-1,min1=-1; | |
136 | Double_t min=10; | |
137 | for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){ | |
138 | AliL3Track *track0=ttt0->GetCheckedTrack(s0); | |
139 | if(!track0) continue; | |
3ea3b9f9 | 140 | if(!track0->IsPoint()) continue; |
108615fc | 141 | for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){ |
142 | AliL3Track *track1=ttt1->GetCheckedTrack(s1); | |
143 | if(!track1) continue; | |
3ea3b9f9 | 144 | if(!track1->IsPoint()) continue; |
99cd2dbf | 145 | |
146 | //Double_t diff = TrackDiff(track0,track1,angle); | |
147 | Double_t diff = CheckTracks(track0,track1,slice); | |
148 | //PrintDiff(track0,track1); | |
149 | if(diff>=0&&diff<min){ | |
108615fc | 150 | min=diff; |
151 | min0=s0; | |
152 | min1=s1; | |
153 | } | |
154 | } | |
155 | } | |
156 | if(min0>=0&&min1>=0){ | |
157 | AliL3Track *track0=ttt0->GetTrack(min0); | |
158 | AliL3Track *track1=ttt1->GetTrack(min1); | |
05144961 | 159 | track[0] = track0; |
108615fc | 160 | track[1] = track1; |
161 | SortGlobalTracks(track,2); | |
05144961 | 162 | track1->CalculateEdgePoint((angle+PI/9)); |
163 | if(track1->IsPoint())//Check if the track will cross the boundary of yet another slice. | |
164 | MultiMerge(ttt1,track,2); | |
165 | else | |
166 | MultiMerge(tout,track,2); | |
108615fc | 167 | track0->CalculateReferencePoint(angle); |
168 | track1->CalculateReferencePoint(angle); | |
99cd2dbf | 169 | PrintDiff(track0,track1); |
108615fc | 170 | FillNtuple(ntuple,track0,track1); |
171 | ttt0->Remove(min0); | |
172 | ttt1->Remove(min1); | |
05144961 | 173 | |
108615fc | 174 | } |
175 | else merge = kFALSE; | |
176 | } | |
3ea3b9f9 | 177 | ttt0->Compress(); |
178 | ttt1->Compress(); | |
108615fc | 179 | LOG(AliL3Log::kInformational,"AliL3GlobalMerger::SlowMerge","Result") |
3ea3b9f9 | 180 | <<AliL3Log::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:" |
181 | <<angle<<ENDLOG; | |
108615fc | 182 | } |
183 | WriteNtuple("ntuple_s.root",ntuple); | |
184 | } | |
185 | ||
186 | void AliL3GlobalMerger::Merge(){ | |
187 | AliL3Track *track[2]; | |
188 | AliL3TrackArray *tout = GetOutTracks(); | |
189 | if(fNSlices<2){ | |
190 | LOG(AliL3Log::kWarning,"AliL3GlobalMerger::Merge","Slice Number") | |
191 | <<"Need more than one Slice!"<<ENDLOG; | |
192 | return; | |
193 | } | |
3ea3b9f9 | 194 | for(Int_t i=0; i<fNSlices; i++){ |
195 | if(fNSlices!=18 && i+1 == fNSlices) continue; //full cicle == 18 slices | |
108615fc | 196 | Int_t slice = fFirst + i; |
197 | AliL3TrackArray *ttt0=GetInTracks(i); | |
3ea3b9f9 | 198 | Int_t slice2 = i+1; |
199 | if(slice2==fNSlices) slice2 =0; | |
200 | AliL3TrackArray *ttt1=GetInTracks(slice2); | |
108615fc | 201 | Float_t angle = PI/18.; //10 degrees -> the border of the slices |
202 | fTransformer->Local2GlobalAngle(&angle,slice); | |
203 | if(i==0) | |
204 | ttt0->QSort(); | |
205 | ttt1->QSort(); | |
206 | Bool_t *ismatched0 = new Bool_t[ttt0->GetNTracks()]; | |
207 | Bool_t *ismatched1 = new Bool_t[ttt1->GetNTracks()]; | |
208 | Int_t n0=0,n1=0; | |
209 | for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){ | |
210 | ismatched0[s0]=kFALSE; | |
211 | AliL3Track *track0=ttt0->GetCheckedTrack(s0); | |
212 | if(!track0) continue; | |
213 | track0->CalculateHelix(); | |
214 | track0->CalculateEdgePoint(angle); | |
215 | if(track0->IsPoint()) {n0++;track0->CalculateReferencePoint(angle);} | |
216 | } | |
217 | for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){ | |
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 | for(Int_t s0=0;s0<ttt0->GetNTracks();s0++){ | |
226 | AliL3Track *track0=ttt0->GetCheckedTrack(s0); | |
227 | if(!track0) continue; | |
228 | if(!track0->IsPoint()) continue; | |
229 | for(Int_t s1=0;s1<ttt1->GetNTracks();s1++){ | |
230 | if(ismatched1[s1]) continue; | |
231 | AliL3Track *track1=ttt1->GetCheckedTrack(s1); | |
232 | if(!track1) continue; | |
233 | if(!track1->IsPoint()) continue; | |
234 | if(IsRTrack(track0,track1)){ | |
235 | track[0] = track0; | |
236 | track[1] = track1; | |
237 | SortGlobalTracks(track,2); | |
3ea3b9f9 | 238 | Double_t r0 = pow(track[0]->GetLastPointX(),2)+ |
239 | pow(track[0]->GetLastPointY(),2); | |
240 | Double_t r1 = pow(track[1]->GetFirstPointX(),2)+ | |
241 | pow(track[1]->GetFirstPointY(),2); | |
242 | if(r0<r1){ | |
243 | MultiMerge(tout,track,2); | |
244 | ismatched0[s0]=kTRUE; | |
245 | ismatched1[s1]=kTRUE; | |
246 | ttt0->Remove(s0); | |
247 | ttt1->Remove(s1); | |
248 | } | |
108615fc | 249 | } |
250 | } | |
251 | } | |
252 | LOG(AliL3Log::kInformational,"AliL3GlobalMerger::Merge","Result") | |
253 | <<AliL3Log::kDec<<"slice0: "<<n0<<" slice1: "<<n1 | |
254 | <<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG; | |
255 | } | |
256 | } |