]>
Commit | Line | Data |
---|---|---|
a6c02c85 | 1 | // @(#) $Id$ |
4aa41877 | 2 | // Original: AliHLTConfMapTrack.cxx,v 1.16 2005/06/14 10:55:21 cvetan |
a6c02c85 | 3 | |
297174de | 4 | //************************************************************************** |
5 | //* This file is property of and copyright by the ALICE HLT Project * | |
6 | //* ALICE Experiment at CERN, All rights reserved. * | |
7 | //* * | |
8 | //* Primary Authors: Anders Vestbo, maintained by * | |
9 | //* Matthias Richter <Matthias.Richter@ift.uib.no> * | |
10 | //* for The ALICE HLT Project. * | |
11 | //* * | |
12 | //* Permission to use, copy, modify and distribute this software and its * | |
13 | //* documentation strictly for non-commercial purposes is hereby granted * | |
14 | //* without fee, provided that the above copyright notice appears in all * | |
15 | //* copies and that both the copyright notice and this permission notice * | |
16 | //* appear in the supporting documentation. The authors make no claims * | |
17 | //* about the suitability of this software for any purpose. It is * | |
18 | //* provided "as is" without express or implied warranty. * | |
19 | //************************************************************************** | |
2a083ac4 | 20 | |
21 | /** @file AliHLTTPCConfMapTrack.cxx | |
22 | @author Anders Vestbo, maintained by Matthias Richter | |
23 | @date | |
24 | @brief Track class for conformal mapper | |
25 | */ | |
a6c02c85 | 26 | |
a6c02c85 | 27 | #include "AliHLTTPCRootTypes.h" |
28 | #include "AliHLTTPCLogging.h" | |
29 | #include "AliHLTTPCVertex.h" | |
30 | #include "AliHLTTPCConfMapPoint.h" | |
31 | #include "AliHLTTPCConfMapFit.h" | |
32 | #include "AliHLTTPCConfMapTrack.h" | |
33 | #include "AliHLTTPCTransform.h" | |
a6c02c85 | 34 | |
a6c02c85 | 35 | #if __GNUC__ >= 3 |
36 | using namespace std; | |
37 | #endif | |
38 | ||
39 | ClassImp(AliHLTTPCConfMapTrack) | |
40 | ||
41 | ||
42 | AliHLTTPCConfMapTrack::AliHLTTPCConfMapTrack() | |
e419b223 | 43 | : |
44 | fCurrentHit(0), | |
45 | fLastHit(0), | |
46 | fFirstHit(0), | |
47 | fs11Xy(0), | |
48 | fs12Xy(0), | |
49 | fs22Xy(0), | |
50 | fg1Xy(0), | |
51 | fg2Xy(0), | |
52 | fs11Sz(0), | |
53 | fs12Sz(0), | |
54 | fs22Sz(0), | |
55 | fg1Sz(0), | |
56 | fg2Sz(0), | |
57 | fddXy(0), | |
58 | fa1Xy(0), | |
59 | fa2Xy(0), | |
60 | fddSz(0), | |
61 | fa1Sz(0), | |
62 | fa2Sz(0) | |
a6c02c85 | 63 | { |
64 | //Constructor | |
65 | fChiSq[0] = 0.; | |
66 | fChiSq[1] = 0.; | |
67 | } | |
68 | ||
69 | AliHLTTPCConfMapTrack::~AliHLTTPCConfMapTrack() | |
70 | { | |
71 | //deconstructor | |
72 | } | |
73 | ||
74 | void AliHLTTPCConfMapTrack::DeleteCandidate() | |
75 | { | |
76 | //Deletes this track by resetting all its parameters. Does not delete | |
77 | //the object itself. | |
78 | ||
79 | AliHLTTPCConfMapPoint *curHit = (AliHLTTPCConfMapPoint*)fFirstHit; | |
80 | AliHLTTPCConfMapPoint *nextHit; | |
81 | ||
82 | while(curHit != 0) | |
83 | { | |
84 | nextHit = (AliHLTTPCConfMapPoint*)curHit->GetNextTrackHit(); | |
85 | curHit->SetNextTrackHit(0); | |
86 | curHit = nextHit; | |
87 | } | |
88 | ||
89 | UInt_t *hit_numbers = GetHitNumbers(); | |
90 | for(Int_t i=0; i<GetNHits(); i++) | |
91 | { | |
92 | //fHitNumbers[i] = 0; | |
93 | hit_numbers[i]=0; | |
94 | } | |
95 | ||
96 | SetRadius(0.); | |
97 | SetCenterX(0.); | |
98 | SetCenterY(0.); | |
99 | ||
100 | ComesFromMainVertex(false); | |
101 | ||
102 | SetNHits(0); | |
103 | SetCharge(0); | |
104 | fChiSq[0] = 0.; | |
105 | fChiSq[1] = 0.; | |
106 | } | |
107 | ||
108 | ||
109 | void AliHLTTPCConfMapTrack::SetProperties(Bool_t usage) | |
110 | { | |
111 | //Set the hits to this track to 'usage' | |
112 | for(StartLoop(); LoopDone(); GetNextHit()) | |
113 | { | |
114 | AliHLTTPCConfMapPoint *p = (AliHLTTPCConfMapPoint*)fCurrentHit; | |
115 | p->SetUsage(usage); | |
116 | } | |
117 | return; | |
118 | } | |
119 | ||
120 | void AliHLTTPCConfMapTrack::Reset() | |
121 | { | |
122 | //Resets the fit parameters of this track. | |
123 | ||
124 | //xy-plane | |
125 | fs11Xy = 0; | |
126 | fs12Xy = 0; | |
127 | fs22Xy = 0; | |
128 | fg1Xy = 0; | |
129 | fg2Xy = 0; | |
130 | fChiSq[0] = 0.; | |
131 | ||
132 | //sz-plane | |
133 | fs11Sz = 0; | |
134 | fs12Sz = 0; | |
135 | fs22Sz = 0; | |
136 | fg1Sz = 0; | |
137 | fg2Sz = 0; | |
138 | fChiSq[1] = 0; | |
139 | SetLength(0); | |
140 | SetNHits(0); | |
141 | } | |
142 | ||
143 | void AliHLTTPCConfMapTrack::UpdateParam(AliHLTTPCConfMapPoint *thisHit) | |
144 | { | |
145 | //Function to update fit parameters of track | |
146 | //Also, it updates the hit pointers. | |
147 | ||
148 | ||
149 | //Increment the number of hits assigned to this track: | |
150 | ||
151 | //fNHits++; | |
152 | Int_t nhits = GetNHits(); | |
153 | nhits++; | |
154 | SetNHits(nhits); //SetNHits(nhits++); | |
155 | ||
156 | //Set the hit pointers: | |
157 | //if(fNHits == 1) | |
158 | if(GetNHits()==1) | |
159 | fFirstHit = thisHit; | |
160 | else | |
161 | ((AliHLTTPCConfMapPoint*)fLastHit)->SetNextTrackHit(thisHit); | |
162 | fLastHit = thisHit; | |
163 | ||
164 | ||
165 | fs11Xy = fs11Xy + thisHit->GetXYWeight() ; | |
166 | fs12Xy = fs12Xy + thisHit->GetXYWeight() * thisHit->GetXprime() ; | |
167 | fs22Xy = fs22Xy + thisHit->GetXYWeight() * pow((thisHit->GetXprime()),2) ; | |
168 | fg1Xy = fg1Xy + thisHit->GetXYWeight() * thisHit->GetYprime() ; | |
169 | fg2Xy = fg2Xy + thisHit->GetXYWeight() * thisHit->GetXprime() * thisHit->GetYprime() ; | |
170 | ||
171 | fddXy = fs11Xy * fs22Xy - pow((fs12Xy),2) ; | |
172 | if ( fddXy != 0 ) | |
173 | { | |
174 | fa1Xy = ( fg1Xy * fs22Xy - fg2Xy * fs12Xy ) / fddXy ; | |
175 | fa2Xy = ( fg2Xy * fs11Xy - fg1Xy * fs12Xy ) / fddXy ; | |
176 | } | |
177 | ||
178 | // Now in the sz plane | |
179 | fs11Sz = fs11Sz + thisHit->GetZWeight() ; | |
180 | fs12Sz = fs12Sz + thisHit->GetZWeight() * thisHit->GetS() ; | |
181 | fs22Sz = fs22Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetS() ; | |
182 | fg1Sz = fg1Sz + thisHit->GetZWeight() * thisHit->GetZ() ; | |
183 | fg2Sz = fg2Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetZ() ; | |
184 | ||
185 | ||
186 | fddSz = fs11Sz * fs22Sz - fs12Sz * fs12Sz ; | |
187 | if ( fddSz != 0 ) { | |
188 | fa1Sz = ( fg1Sz * fs22Sz - fg2Sz * fs12Sz ) / fddSz ; | |
189 | fa2Sz = ( fg2Sz * fs11Sz - fg1Sz * fs12Sz ) / fddSz ; | |
190 | } | |
191 | } | |
192 | ||
193 | ||
194 | void AliHLTTPCConfMapTrack::Fill(AliHLTTPCVertex *vertex,Double_t max_Dca) | |
195 | { | |
db16520a | 196 | //Fill track variables with or without fit. |
197 | ||
db16520a | 198 | // for straight line fit |
199 | if (AliHLTTPCTransform::GetBFieldValue() == 0.0 ){ | |
200 | ||
201 | SetRadius(0.); | |
202 | SetPt(0.); | |
203 | ||
204 | //go for fit of straight line in real space | |
205 | AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex); | |
a7c32962 | 206 | /* Matthias 13.12.2006 |
207 | * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far | |
208 | * and has always been kTRUE. | |
209 | * In order to remove the AliHLTTPC class (which is the old steering class for | |
210 | * HLT (TPC) tracking) from the compilation, this function can not be activated | |
211 | * again. We have to think about a more elegant way to specify the parameters | |
212 | * anyway. | |
db16520a | 213 | ComesFromMainVertex(AliHLTTPC::DoVertexFit()); |
a7c32962 | 214 | */ |
215 | ComesFromMainVertex(kTRUE); | |
db16520a | 216 | fit->FitStraightLine(); |
217 | ||
218 | AliHLTTPCConfMapPoint *fHit = (AliHLTTPCConfMapPoint*)fFirstHit; | |
219 | SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ()); | |
220 | ||
221 | UpdateToFirstPoint(); | |
222 | ||
223 | delete fit; | |
224 | ||
a6c02c85 | 225 | } |
db16520a | 226 | // for helix fit |
227 | else { | |
437e8e54 | 228 | //fRadius = sqrt(fa2Xy*fa2Xy+1)/(2*fabs(fa1Xy)); |
229 | Double_t radius = sqrt(fa2Xy*fa2Xy+1)/(2*fabs(fa1Xy)); | |
230 | SetRadius(radius); | |
231 | ||
232 | //fPt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * fRadius); | |
233 | Double_t pt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * GetRadius()); | |
234 | SetPt(pt); | |
31f11c63 | 235 | //Set Error here????? |
437e8e54 | 236 | |
237 | if(GetPt() > max_Dca) //go for fit of helix in real space | |
db16520a | 238 | { |
437e8e54 | 239 | AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex); |
a7c32962 | 240 | /* Matthias 13.12.2006 |
241 | * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far | |
242 | * and has always been kTRUE. | |
243 | * In order to remove the AliHLTTPC class (which is the old steering class for | |
244 | * HLT (TPC) tracking) from the compilation, this function can not be activated | |
245 | * again. We have to think about a more elegant way to specify the parameters | |
246 | * anyway. | |
db16520a | 247 | ComesFromMainVertex(AliHLTTPC::DoVertexFit()); |
a7c32962 | 248 | */ |
437e8e54 | 249 | ComesFromMainVertex(kTRUE); |
250 | fit->FitHelix(); | |
251 | ||
252 | //AliHLTTPCConfMapPoint *lHit = (AliHLTTPCConfMapPoint*)fLastHit; | |
253 | AliHLTTPCConfMapPoint *fHit = (AliHLTTPCConfMapPoint*)fFirstHit; | |
254 | SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ()); | |
255 | ||
256 | UpdateToFirstPoint(); | |
257 | ||
258 | delete fit; | |
db16520a | 259 | } |
437e8e54 | 260 | else if(GetPt() == 0) |
fc455fba | 261 | { |
437e8e54 | 262 | LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<< |
263 | "Found track with Pt=0!!!"<<ENDLOG; | |
fc455fba | 264 | } |
437e8e54 | 265 | else |
db16520a | 266 | { |
437e8e54 | 267 | LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<< |
268 | "Track with pt<max_Dca :"<<GetPt()<<ENDLOG; | |
db16520a | 269 | } |
a6c02c85 | 270 | } |
271 | } | |
272 | ||
273 | Int_t AliHLTTPCConfMapTrack::GetMCLabel() | |
274 | { | |
275 | //For evaluation study. | |
276 | //Returns the MCtrackID of the belonging clusters. | |
277 | //If MCLabel < 0, means that track is fake. | |
278 | ||
279 | return 0; | |
280 | /* | |
281 | Int_t num_of_clusters = GetNumberOfPoints(); | |
282 | S *s=new S[num_of_clusters]; | |
283 | Int_t i; | |
284 | for (i=0; i<num_of_clusters; i++) s[i].lab=s[i].max=0; | |
285 | ||
286 | Int_t lab=123456789; | |
287 | for (i=0; i<num_of_clusters; i++) { | |
288 | AliHLTTPCConfMapPoint *c=(AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(i); | |
289 | lab=fabs(c->fMCTrackID[0]); | |
290 | Int_t j; | |
291 | for (j=0; j<num_of_clusters; j++) | |
292 | if (s[j].lab==lab || s[j].max==0) break; | |
293 | s[j].lab=lab; | |
294 | s[j].max++; | |
295 | } | |
296 | ||
297 | Int_t max=0; | |
298 | for (i=0; i<num_of_clusters; i++) | |
299 | if (s[i].max>max) {max=s[i].max; lab=s[i].lab;} | |
300 | ||
301 | delete[] s; | |
302 | ||
303 | for (i=0; i<num_of_clusters; i++) { | |
304 | AliHLTTPCConfMapPoint *c=(AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(i); | |
305 | if (fabs(c->fMCTrackID[1]) == lab || | |
306 | fabs(c->fMCTrackID[2]) == lab ) max++; | |
307 | } | |
308 | ||
309 | //check if more than 10% of the clusters are incorrectly assigned (fake track): | |
310 | ||
311 | if (1.-Float_t(max)/num_of_clusters > 0.10) | |
312 | { | |
313 | return -lab; | |
314 | } | |
315 | Int_t tail=Int_t(0.08*174); | |
316 | if (num_of_clusters < tail) return lab; | |
317 | ||
318 | max=0; | |
319 | for (i=1; i<=tail; i++) { | |
320 | AliHLTTPCConfMapPoint *c = (AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(num_of_clusters-i); | |
321 | if (lab == fabs(c->fMCTrackID[0]) || | |
322 | lab == fabs(c->fMCTrackID[1]) || | |
323 | lab == fabs(c->fMCTrackID[2])) max++; | |
324 | } | |
325 | if (max < Int_t(0.5*tail)) | |
326 | { | |
327 | //printf("Wrong innermost clusters\n"); | |
328 | return -lab; | |
329 | } | |
330 | return lab; | |
331 | */ | |
332 | } | |
333 |