2 // Original: AliHLTGlobalMerger.cxx,v 1.13 2005/06/14 10:55:21 cvetan
4 /**************************************************************************
5 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
7 * Authors: Uli Frankenfeld *
8 * Matthias Richter <Matthias.Richter@ift.uib.no> *
9 * for The ALICE Off-line Project. *
11 * Permission to use, copy, modify and distribute this software and its *
12 * documentation strictly for non-commercial purposes is hereby granted *
13 * without fee, provided that the above copyright notice appears in all *
14 * copies and that both the copyright notice and this permission notice *
15 * appear in the supporting documentation. The authors make no claims *
16 * about the suitability of this software for any purpose. It is *
17 * provided "as is" without express or implied warranty. *
18 **************************************************************************/
20 /** @file AliHLTTPCGlobalMerger.cxx
21 @author Uli Frankenfeld, maintained by Matthias Richter
23 @brief The HLT TPC slice merger
26 #include "AliHLTTPCLogging.h"
27 #include "AliHLTTPCGlobalMerger.h"
28 #include "AliHLTTPCTrack.h"
29 #include "AliHLTTPCTransform.h"
30 #include "AliHLTTPCTrackArray.h"
36 ClassImp(AliHLTTPCGlobalMerger)
38 AliHLTTPCGlobalMerger::AliHLTTPCGlobalMerger()
40 //Default constructor. Use Setup to specify and setup the necessary parameters and arrays.
42 SetParameter(0,0,0,0,0);
49 AliHLTTPCGlobalMerger::~AliHLTTPCGlobalMerger()
54 void AliHLTTPCGlobalMerger::Setup(Int_t first,Int_t last)
56 //Used to setup the arrays and everything
58 fNSlices = last-first+1;
61 InitMerger(last-first+1);
64 void AliHLTTPCGlobalMerger::InitSlice(Int_t slice)
67 // Select Sector The following FillTracks call will
71 fCurrentTracks = fSlice - fFirst;
74 Double_t AliHLTTPCGlobalMerger::CheckTracks(AliHLTTPCTrack *innertrack,AliHLTTPCTrack *outertrack,Int_t slice)
76 //Compare the tracks by propagating the outermost track to the last and first point plane
77 //of the innermost track. This plane is defined by the padrow plane where these points
80 if(innertrack->GetCharge()!=outertrack->GetCharge()) return -1;
82 Float_t angle = 0;//perpendicular to the padrowplane (in local system)
83 AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
84 Double_t dx[2],dy[2],dz[2];
86 AliHLTTPCTrack *tracks[2];
87 tracks[0] = innertrack;
88 tracks[1] = outertrack;
89 SortGlobalTracks(tracks,2);
90 innertrack = tracks[0];
91 outertrack = tracks[1];
95 point[0]=innertrack->GetLastPointX();
96 point[1]=innertrack->GetLastPointY();
97 point[2]=innertrack->GetLastPointZ();
98 AliHLTTPCTransform::Global2LocHLT(point,slice);
100 outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
101 if(!outertrack->IsPoint()) return diff;
102 dx[0] = fabs(outertrack->GetPointX()-innertrack->GetLastPointX());
103 dy[0] = fabs(outertrack->GetPointY()-innertrack->GetLastPointY());
104 dz[0] = fabs(outertrack->GetPointZ()-innertrack->GetLastPointZ());
106 point[0]=innertrack->GetFirstPointX();
107 point[1]=innertrack->GetFirstPointY();
108 point[2]=innertrack->GetFirstPointZ();
109 AliHLTTPCTransform::Global2LocHLT(point,slice);
111 outertrack->CalculateReferencePoint(angle,point[0]);//local x = global distance to padrowplane
112 if(!outertrack->IsPoint()) return diff;
113 dx[1] = fabs(outertrack->GetPointX()-innertrack->GetFirstPointX());
114 dy[1] = fabs(outertrack->GetPointY()-innertrack->GetFirstPointY());
115 dz[1] = fabs(outertrack->GetPointZ()-innertrack->GetFirstPointZ());
117 diff=0;//This was a tough bug to find....
118 for(Int_t i=0; i<2; i++)
119 diff += sqrt(dx[i]*dx[i] + dy[i]*dy[i] + dz[i]*dz[i]);
123 void AliHLTTPCGlobalMerger::SlowMerge(Char_t *path)
125 //Tuning of parameters. This matches _all_ tracks between two neighbouring
126 //slices, and merges the ones which are closest in space. The difference
127 //is written to a ntuppel, which can be used as a input for the SetParameters
128 //when using normal Merge function.
131 void* ntuple=GetNtuple();
132 AliHLTTPCTrack *track[2];
133 AliHLTTPCTrackArray *tout = GetOutTracks();
136 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCGlobalMerger::SlowMerge","Slice Number")
137 <<"Need more than one Slice!"<<ENDLOG;
141 for(Int_t i=0; i<fNSlices; i++)
143 //if(fNSlices!=18 && i+1 == fNSlices) continue;
144 Int_t slice = fFirst + i;
145 AliHLTTPCTrackArray *ttt0=GetInTracks(i);
147 //if(slice2==fNSlices) slice2 =0;
149 //Make sure slices are on the same side of the TPC
150 if(slice2 == 18) slice2=0;
151 else if(slice2 == 36) slice2=18;
152 AliHLTTPCTrackArray *ttt1=GetInTracks(slice2);
153 //10 degrees -> the border of the slices in local coordinates
154 Float_t angle = AliHLTTPCTransform::Pi()/18;
155 AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
157 //In the two following cases, the angle is 2*pi, so set it back to 0 in order for
158 //the calculation of crossing points to be correct.
159 if(slice==17 || slice==35)
164 for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
166 AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
167 if(!track0) continue;
168 track0->CalculateHelix();
169 track0->CalculateEdgePoint(angle);
170 // if(track0->IsPoint()) AddTrack(tout,track0);
172 for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
174 AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
175 if(!track1) continue;
176 track1->CalculateHelix();
177 track1->CalculateEdgePoint(angle);
178 // if(track1->IsPoint()) AddTrack(tout,track1);
180 Bool_t merge = kTRUE;
183 Int_t min0=-1,min1=-1;
185 Int_t n0=ttt0->GetNTracks(),n1=ttt1->GetNTracks();
186 for(Int_t s0=0;s0<n0;s0++)
188 AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
189 if(!track0) continue;
190 if(!track0->IsPoint()) continue;
191 for(Int_t s1=0;s1<n1;s1++)
193 AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
194 if(!track1) continue;
195 if(!track1->IsPoint()) continue;
197 //Double_t diff = TrackDiff(track0,track1,angle);
198 Double_t diff = CheckTracks(track0,track1,slice);
199 //PrintDiff(track0,track1);
200 if(diff>=0&&diff<min)
210 AliHLTTPCTrack *track0=ttt0->GetTrack(min0);
211 AliHLTTPCTrack *track1=ttt1->GetTrack(min1);
214 SortGlobalTracks(track,2);
215 track1->CalculateEdgePoint((angle+AliHLTTPCTransform::Pi()/9));
216 if(track1->IsPoint())//Check if the track will cross the boundary of yet another slice.
217 MultiMerge(ttt1,track,2);
219 MultiMerge(tout,track,2);
220 track0->CalculateReferencePoint(angle);
221 track1->CalculateReferencePoint(angle);
222 //PrintDiff(track0,track1);
223 FillNtuple(ntuple,track0,track1);
232 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCGlobalMerger::SlowMerge","Result")
233 <<AliHLTTPCLog::kDec<<"Merged Tracks: "<<tout->GetNTracks()<<" at:"
237 sprintf(fname,"%s/merge_parameters.root",path);
238 WriteNtuple(fname,ntuple);
241 void AliHLTTPCGlobalMerger::Merge()
243 //Normal merging procedure. Matches tracks which are within limits
244 //set by SetParameters. Parameters can be tuned by SlowMerge.
246 AliHLTTPCTrack *track[2];
247 AliHLTTPCTrackArray *tout = GetOutTracks();
250 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCGlobalMerger::Merge","Slice Number")
251 <<"Need more than one Slice!"<<ENDLOG;
254 for(Int_t i=0; i<fNSlices; i++)
256 //if(fNSlices!=18 && i+1 == fNSlices) continue;
257 Int_t slice = fFirst + i;
258 AliHLTTPCTrackArray *ttt0=GetInTracks(i);
260 //if(slice2==fNSlices) slice2 =0;
262 //Make sure slices are on the same side of the TPC
263 if(slice2 == 18) slice2=0;
264 else if(slice2 == 36) slice2=18;
265 AliHLTTPCTrackArray *ttt1=GetInTracks(slice2);
266 //10 degrees -> the border of the slices in local coordinates
267 Float_t angle = AliHLTTPCTransform::Pi()/18;
268 AliHLTTPCTransform::Local2GlobalAngle(&angle,slice);
270 //In the two following cases, the angle is 2*pi, so set it back to 0 in order for
271 //the calculation of crossing points to be correct.
272 if(slice==17 || slice==35)
277 Bool_t *ismatched0 = new Bool_t[ttt0->GetNTracks()];
278 Bool_t *ismatched1 = new Bool_t[ttt1->GetNTracks()];
280 for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
282 ismatched0[s0]=kFALSE;
283 AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
284 if(!track0) continue;
285 track0->CalculateHelix();
286 track0->CalculateEdgePoint(angle);
287 if(track0->IsPoint())
290 track0->CalculateReferencePoint(angle);
293 for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
295 ismatched1[s1]=kFALSE;
296 AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
297 if(!track1) continue;
298 track1->CalculateHelix();
299 track1->CalculateEdgePoint(angle);
300 if(track1->IsPoint())
303 track1->CalculateReferencePoint(angle);
306 for(Int_t s0=0;s0<ttt0->GetNTracks();s0++)
308 if(ismatched0[s0]) continue;
309 AliHLTTPCTrack *track0=ttt0->GetCheckedTrack(s0);
310 if(!track0) continue;
311 if(!track0->IsPoint()) continue;
312 for(Int_t s1=0;s1<ttt1->GetNTracks();s1++)
314 if(ismatched1[s1]) continue;
315 AliHLTTPCTrack *track1=ttt1->GetCheckedTrack(s1);
316 if(!track1) continue;
317 if(!track1->IsPoint()) continue;
318 if(IsRTrack(track0,track1))
322 SortGlobalTracks(track,2);
323 Double_t r0 = pow(track[0]->GetLastPointX(),2)+
324 pow(track[0]->GetLastPointY(),2);
325 Double_t r1 = pow(track[1]->GetFirstPointX(),2)+
326 pow(track[1]->GetFirstPointY(),2);
329 MultiMerge(tout,track,2);
330 ismatched0[s0]=kTRUE;
331 ismatched1[s1]=kTRUE;
336 The track is merged, so we will _not_ look for more matches.
337 Because there could easily be more matches, if a track is being
338 split within the sector....
344 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCGlobalMerger::Merge","Result")
345 <<AliHLTTPCLog::kDec<<"slice0: "<<n0<<" slice1: "<<n1
346 <<" Merged Tracks: "<<tout->GetNTracks()<<ENDLOG;
347 delete [] ismatched0;
348 delete [] ismatched1;