]>
Commit | Line | Data |
---|---|---|
2874a2f5 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* $Id: $ */ | |
17 | ||
18 | //_________________________________________________________________________// | |
19 | //_________________________________________________________________________// | |
20 | ||
21 | #include "AliESDTOFCluster.h" | |
22 | #include "TClonesArray.h" | |
23 | #include "AliESDEvent.h" | |
24 | ||
25 | ClassImp(AliESDTOFCluster) | |
26 | ||
27 | //_________________________________________________________________________ | |
28 | AliESDTOFCluster::AliESDTOFCluster(Int_t clID) : | |
29 | fID(clID), | |
30 | fNTOFhits(0), | |
31 | fStatus(0), | |
32 | fNmatchableTracks(0) | |
33 | { | |
34 | // | |
35 | // default ctor | |
36 | // | |
37 | ||
38 | for(Int_t i=kMaxHits;i--;) fHitIndex[i] = -1; | |
39 | for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1; | |
40 | } | |
41 | ||
42 | //_________________________________________________________________________ | |
43 | AliESDTOFCluster::AliESDTOFCluster(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t , | |
44 | Bool_t ,Float_t ,Float_t ,Float_t , | |
45 | Int_t ,Float_t ,Float_t ,Float_t ,Float_t ,Double_t*) : | |
46 | fID(-1), | |
47 | fNTOFhits(0), | |
48 | fStatus(1), | |
49 | fNmatchableTracks(1) | |
50 | { | |
51 | // | |
52 | // Constructor of AliESDTOFCluster object | |
53 | // | |
54 | ||
55 | // to be replaced with hit creation | |
56 | for(Int_t i=kMaxHits;i--;) fHitIndex[i] = -1; | |
57 | for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1; | |
58 | // | |
59 | } | |
60 | ||
61 | //_________________________________________________________________________ | |
62 | AliESDTOFCluster::AliESDTOFCluster(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t , | |
63 | Bool_t ,Float_t ,Float_t ,Float_t ) : | |
64 | fID(-1), | |
65 | fNTOFhits(0), | |
66 | fStatus(1), | |
67 | fNmatchableTracks(0) | |
68 | { | |
69 | // | |
70 | // Constructor of AliESDTOFCluster object | |
71 | // | |
72 | ||
73 | // to be replaced with hit creation | |
74 | for(Int_t i=kMaxHits;i--;) fHitIndex[i] = -1; | |
75 | for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1; | |
76 | ||
77 | } | |
78 | ||
79 | //_________________________________________________________________________ | |
80 | AliESDTOFCluster::AliESDTOFCluster(const AliESDTOFCluster & source) : | |
81 | AliVTOFcluster(source), | |
82 | fID(source.fID), | |
83 | fNTOFhits(source.fNTOFhits), | |
84 | fStatus(source.fStatus), | |
85 | fNmatchableTracks(source.fNmatchableTracks) | |
86 | { | |
87 | // | |
88 | // copy ctor for AliESDTOFCluster object | |
89 | // | |
90 | ||
91 | SetEvent(source.GetEvent()); | |
92 | ||
93 | for(Int_t i=kMaxHits;i--;) fHitIndex[i] = source.fHitIndex[i]; | |
94 | for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = source.fMatchIndex[i]; | |
95 | ||
96 | } | |
97 | ||
98 | //_________________________________________________________________________ | |
99 | AliESDTOFCluster & AliESDTOFCluster::operator=(const AliESDTOFCluster & source) | |
100 | { | |
101 | // | |
102 | // assignment op-r | |
103 | // | |
104 | if (this == &source) return *this; | |
105 | AliVTOFcluster::operator=(source); | |
106 | fID = source.fID; | |
107 | fNTOFhits = source.fNTOFhits; | |
108 | fStatus = source.fStatus; | |
109 | fNmatchableTracks = source.fNmatchableTracks; | |
110 | ||
111 | for(Int_t i=kMaxHits;i--;) fHitIndex[i] = source.fHitIndex[i]; | |
112 | for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = source.fMatchIndex[i]; | |
113 | ||
114 | return *this; | |
115 | } | |
116 | ||
117 | //_________________________________________________________________________ | |
118 | Int_t AliESDTOFCluster::Update(Int_t trackIndex,Float_t dX,Float_t dY,Float_t dZ, | |
119 | Float_t length,Double_t expTimes[AliPID::kSPECIESC]) | |
120 | { | |
121 | // update cluster info by new track | |
122 | // AliInfo(Form("TOF %d %d",fNmatchableTracks,fNTOFhits)); | |
123 | ||
124 | if(fNmatchableTracks >= kMaxMatches) return 2; // max number reached | |
125 | // | |
126 | // check if the track is not already stored | |
127 | for (Int_t ii=fNmatchableTracks; ii--;) if (trackIndex==GetTrackIndex(ii)) return 1; | |
128 | // | |
129 | const AliESDEvent *event = (AliESDEvent *) GetEvent(); | |
130 | TClonesArray *matchAr = event->GetESDTOFMatches(); | |
131 | int ntr = matchAr->GetEntriesFast(); | |
132 | new((*matchAr)[ntr]) AliESDTOFMatch(trackIndex,expTimes,dX,dY,dZ,length); | |
a853160f | 133 | int nmt = fNmatchableTracks++; |
134 | fMatchIndex[nmt] = ntr; | |
2874a2f5 | 135 | // |
136 | return 0; | |
137 | // | |
138 | } | |
139 | ||
140 | //_________________________________________________________________________ | |
141 | void AliESDTOFCluster::AddESDTOFHitIndex(Int_t hitID) | |
142 | { | |
143 | // register new hit in the cluster | |
144 | if(fNTOFhits >= kMaxHits) return; | |
a853160f | 145 | int nth = fNTOFhits++; |
146 | fHitIndex[nth] = hitID; // add the hit to the array | |
2874a2f5 | 147 | } |
148 | ||
149 | //_________________________________________________________________________ | |
150 | void AliESDTOFCluster::AddTOFhit(AliESDTOFHit *hit) | |
151 | { | |
152 | // add new hit | |
153 | if(fNTOFhits >= kMaxHits) return; | |
154 | // add the hit to the array | |
155 | const AliESDEvent *event = (AliESDEvent *) GetEvent(); | |
156 | TClonesArray *hitAr = event->GetESDTOFHits(); | |
157 | int nh = hitAr->GetEntriesFast(); | |
158 | new((*hitAr)[nh]) AliESDTOFHit(*hit); | |
159 | // hitN->SetIndex(nh); // RS: why do we need this | |
a853160f | 160 | int nth = fNTOFhits++; |
161 | fHitIndex[nth] = nh; | |
2874a2f5 | 162 | // |
163 | } | |
164 | ||
165 | //_________________________________________________________________________ | |
166 | void AliESDTOFCluster::AddTOFhit(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t , Bool_t ,Float_t ,Float_t ,Float_t ) | |
167 | { | |
168 | } | |
169 | ||
170 | //_________________________________________________________________________ | |
171 | Int_t AliESDTOFCluster::GetClusterIndex(int ihit) const | |
172 | { | |
173 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
174 | return hit ? hit->GetClusterIndex() : -1; | |
175 | } | |
176 | ||
177 | //_________________________________________________________________________ | |
178 | Int_t AliESDTOFCluster::GetTOFchannel(int ihit) const | |
179 | { | |
180 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
181 | return hit ? hit->GetTOFchannel() : -1; | |
182 | } | |
183 | ||
184 | //_________________________________________________________________________ | |
185 | Float_t AliESDTOFCluster::GetTime(int ihit) const | |
186 | { | |
187 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
188 | return hit ? hit->GetTime() : 0; | |
189 | } | |
190 | ||
191 | //_________________________________________________________________________ | |
192 | Float_t AliESDTOFCluster::GetTimeRaw(Int_t ihit) const | |
193 | { | |
194 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
195 | return hit ? hit->GetTimeRaw() : 0; | |
196 | } // TOF raw time | |
197 | ||
198 | //_________________________________________________________________________ | |
199 | Float_t AliESDTOFCluster::GetTOT(Int_t ihit) const | |
200 | { | |
201 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
202 | return hit ? hit->GetTOT() : 0; | |
203 | } // TOF tot | |
204 | ||
205 | //_________________________________________________________________________ | |
206 | Float_t AliESDTOFCluster::GetTOFsignalToT(Int_t ihit) const | |
207 | { | |
208 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
209 | return hit ? hit->GetTOT() : 0; // RS: Why signalTot and TOT are the same? | |
210 | } // TOF tot | |
211 | ||
212 | //_________________________________________________________________________ | |
213 | Int_t AliESDTOFCluster::GetLabel(Int_t i,Int_t ihit) const | |
214 | { | |
215 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
216 | if (!hit || i>=3) return -999; | |
217 | return hit->GetTOFLabel(i); | |
218 | } | |
219 | ||
220 | //_________________________________________________________________________ | |
221 | Int_t AliESDTOFCluster::GetDeltaBC(Int_t ihit) const | |
222 | { | |
223 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
224 | return hit ? hit->GetDeltaBC() : 0; | |
225 | } | |
226 | ||
227 | //_________________________________________________________________________ | |
228 | Int_t AliESDTOFCluster::GetL0L1Latency(Int_t ihit) const | |
229 | { | |
230 | AliESDTOFHit* hit = GetTOFHit(ihit); | |
231 | return hit ? hit->GetL0L1Latency() : 0; | |
232 | } | |
233 | ||
234 | //_________________________________________________________________________ | |
235 | Bool_t AliESDTOFCluster::GetStatus() const | |
236 | { | |
237 | if(!fEvent){ | |
238 | AliInfo("No AliESDEvent available here!"); | |
239 | return 0; | |
240 | } | |
241 | return fStatus; | |
242 | } | |
243 | ||
244 | //_________________________________________________________________________ | |
245 | Float_t AliESDTOFCluster::GetZ() const | |
246 | { | |
247 | AliESDTOFHit* hit = GetTOFHit(0); | |
248 | return hit ? hit->GetZ() : 0; | |
249 | } | |
250 | ||
251 | //_________________________________________________________________________ | |
252 | Float_t AliESDTOFCluster::GetPhi() const | |
253 | { | |
254 | AliESDTOFHit* hit = GetTOFHit(0); | |
255 | return hit ? hit->GetPhi() : 0; | |
256 | } | |
257 | ||
258 | //_________________________________________________________________________ | |
259 | Float_t AliESDTOFCluster::GetR() const | |
260 | { | |
261 | AliESDTOFHit* hit = GetTOFHit(0); | |
262 | return hit ? hit->GetR() : 0; | |
263 | } | |
264 | ||
265 | //_________________________________________________________________________ | |
266 | Int_t AliESDTOFCluster::GetNMatchableTracks() const | |
267 | { | |
268 | return fNmatchableTracks; | |
269 | } | |
270 | ||
271 | //_________________________________________________________________________ | |
272 | Int_t AliESDTOFCluster::GetNTOFhits() const | |
273 | { | |
274 | return fNTOFhits; | |
275 | } | |
276 | ||
277 | //_________________________________________________________________________ | |
278 | Int_t AliESDTOFCluster::GetTrackIndex(Int_t i) const | |
279 | { | |
280 | AliESDTOFMatch* match = 0; | |
281 | return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetTrackIndex() : -999; | |
282 | } | |
283 | ||
284 | //_________________________________________________________________________ | |
285 | Float_t AliESDTOFCluster::GetDistanceInStripPlane(Int_t i) const | |
286 | { | |
287 | // distance | |
288 | AliESDTOFMatch* match = 0; | |
289 | if (i>=fNmatchableTracks || !(match=GetTOFMatch(i))) return -999; | |
290 | Double_t dz = match->GetDz(); | |
291 | Double_t dx = match->GetDx(); | |
292 | return TMath::Sqrt(dx*dx+dz*dz); | |
293 | } | |
294 | ||
295 | //_________________________________________________________________________ | |
296 | Float_t AliESDTOFCluster::GetDx(Int_t i) const | |
297 | { | |
298 | AliESDTOFMatch* match = 0; | |
299 | return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDx() : -999; | |
300 | } // distance, X component | |
301 | ||
302 | //_________________________________________________________________________ | |
303 | Float_t AliESDTOFCluster::GetDy(Int_t i) const | |
304 | { | |
305 | AliESDTOFMatch* match = 0; | |
306 | return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDy() : -999; | |
307 | } // distance, Y component | |
308 | ||
309 | //_________________________________________________________________________ | |
310 | Float_t AliESDTOFCluster::GetDz(Int_t i) const | |
311 | { | |
312 | AliESDTOFMatch* match = 0; | |
313 | return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDz() : -999; | |
314 | } // distance, Z component | |
315 | ||
316 | //_________________________________________________________________________ | |
317 | Float_t AliESDTOFCluster::GetLength(Int_t i) const | |
318 | { | |
319 | AliESDTOFMatch* match = 0; | |
320 | return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetTrackLength() : -999.; | |
321 | } // reconstructed track length at TOF | |
322 | ||
323 | //_________________________________________________________________________ | |
324 | Double_t AliESDTOFCluster::GetIntegratedTime(Int_t iPart,Int_t i) const | |
325 | { | |
326 | AliESDTOFMatch* match = 0; | |
327 | return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetIntegratedTimes(iPart) : -999.; | |
328 | } // reconstructed track length at TOF | |
329 | ||
330 | //_________________________________________________________________________ | |
331 | void AliESDTOFCluster::Print(const Option_t*) const | |
332 | { | |
333 | // print full chain | |
334 | printf("#%5d TOF Cluster %5d of %d Hits, %d Matchable Tracks\n",GetESDID(),fID, fNTOFhits, fNmatchableTracks); | |
335 | for (int ih=0;ih<fNTOFhits;ih++) { | |
336 | AliESDTOFHit* ht = GetTOFHit(ih); | |
337 | if (ht) { | |
338 | printf("%d: ",ih); | |
339 | ht->Print(); | |
340 | } | |
341 | } | |
342 | // | |
343 | for (int it=0;it<fNmatchableTracks;it++) { | |
344 | AliESDTOFMatch* mt = GetTOFMatch(it); | |
345 | if (mt) { | |
346 | printf("%d: ",it); | |
347 | mt->Print(); | |
348 | } | |
349 | } | |
350 | // | |
351 | } | |
352 | ||
353 | //_________________________________________________________________________ | |
354 | AliESDTOFHit* AliESDTOFCluster::GetTOFHit(Int_t i) const | |
355 | { | |
356 | return fEvent ? ((AliESDTOFHit *) ((AliESDEvent *) GetEvent())->GetESDTOFHits()->At(fHitIndex[i])):0; | |
357 | } | |
358 | ||
359 | //_________________________________________________________________________ | |
360 | AliESDTOFMatch* AliESDTOFCluster::GetTOFMatch(Int_t i) const | |
361 | { | |
362 | return fEvent ? ((AliESDTOFMatch *) ((AliESDEvent *) GetEvent())->GetESDTOFMatches()->At(fMatchIndex[i])) : 0; | |
363 | } | |
364 | ||
365 | //_________________________________________________________________________ | |
366 | void AliESDTOFCluster::SuppressMatchedTrack(Int_t id) | |
367 | { | |
368 | // suppress the reference to track id | |
369 | for (int it=fNmatchableTracks;it--;) { | |
370 | AliESDTOFMatch* mtc = GetTOFMatch(it); | |
371 | if (mtc->GetTrackIndex()!=id) continue; | |
372 | // need to suprress the match: simply remove reference to it | |
373 | int rmID = fMatchIndex[it]; | |
374 | for (int jt=it+1;jt<fNmatchableTracks;jt++) fMatchIndex[jt-1] = fMatchIndex[jt]; | |
375 | fNmatchableTracks--; | |
376 | // remove match rmID | |
377 | TClonesArray* arrMatch = ((AliESDEvent *)GetEvent())->GetESDTOFMatches(); | |
378 | int last = arrMatch->GetEntriesFast()-1; | |
379 | AliESDTOFMatch* mtcL = (AliESDTOFMatch*)arrMatch->At(last); | |
380 | if (rmID!=last) { | |
381 | *mtc = *mtcL; // assign the last match to removed slot | |
382 | int trID = mtc->GetTrackIndex(); | |
383 | AliESDtrack* trc = ((AliESDEvent *)GetEvent())->GetTrack(trID); | |
384 | trc->ReplaceTOFMatchID(last,rmID); // fix the reference to reassigned match | |
385 | // fix the | |
386 | } | |
387 | arrMatch->RemoveAt(last); | |
388 | break; | |
389 | } | |
390 | // | |
391 | if (!fNmatchableTracks) { // no matches left, clear all hits: prepare for selfelimination | |
392 | // first remove associated hits | |
393 | TClonesArray* arrHits = ((AliESDEvent *)GetEvent())->GetESDTOFHits(); | |
394 | TClonesArray* arrClus = ((AliESDEvent *)GetEvent())->GetESDTOFClusters(); | |
395 | int last = arrHits->GetEntriesFast()-1; | |
396 | for (;fNTOFhits--;) { // remove hits | |
a853160f | 397 | int hID = fHitIndex[int(fNTOFhits)]; |
2874a2f5 | 398 | AliESDTOFHit* hit = (AliESDTOFHit*)arrHits->At(hID); |
399 | AliESDTOFHit* hitL = (AliESDTOFHit*)arrHits->At(last); | |
400 | if (hID!=last) { | |
401 | *hit = *hitL; // assign the last match to removed slot | |
402 | // fix reference on hitL in the owner cluster | |
403 | int clID = hit->GetESDTOFClusterIndex(); | |
404 | AliESDTOFCluster* clusL = (AliESDTOFCluster*)arrClus->At(clID); | |
405 | clusL->ReplaceHitID(last,hID); | |
406 | } | |
407 | arrHits->RemoveAt(last--); | |
408 | } | |
409 | } | |
410 | ||
411 | } | |
412 | ||
413 | //_________________________________________________________________________ | |
414 | void AliESDTOFCluster::ReplaceHitID(int oldID, int newID) | |
415 | { | |
416 | // replace the reference to hit from oldID by newID | |
417 | for (int it=fNTOFhits;it--;) { | |
418 | if (fHitIndex[it]==oldID) { | |
419 | fHitIndex[it]=newID; | |
420 | return; | |
421 | } | |
422 | } | |
423 | } | |
424 | ||
425 | //_________________________________________________________________________ | |
426 | void AliESDTOFCluster::ReplaceMatchID(int oldID, int newID) | |
427 | { | |
428 | // replace the reference to match from oldID by newID | |
429 | for (int it=fNmatchableTracks;it--;) { | |
430 | if (fMatchIndex[it]==oldID) { | |
431 | fMatchIndex[it]=newID; | |
432 | return; | |
433 | } | |
434 | } | |
435 | } | |
436 | ||
437 | //_________________________________________________________________________ | |
438 | void AliESDTOFCluster::ReplaceMatchedTrackID(int oldID, int newID) | |
439 | { | |
440 | // replace the reference to track oldID by newID | |
441 | for (int it=fNmatchableTracks;it--;) { | |
442 | AliESDTOFMatch* mtc = GetTOFMatch(it); | |
443 | if (mtc->GetTrackIndex()!=oldID) continue; | |
444 | mtc->SetTrackIndex(newID); | |
445 | break; | |
446 | } | |
447 | // | |
448 | } | |
449 | ||
450 | //_________________________________________________________________________ | |
451 | void AliESDTOFCluster::FixSelfReferences(int oldID, int newID) | |
452 | { | |
453 | // replace the references (in tracks and hist) to this cluster from oldID by newID | |
454 | for (int it=fNmatchableTracks;it--;) { | |
455 | int trID = GetTOFMatch(it)->GetTrackIndex(); | |
456 | AliESDtrack* trc = ((AliESDEvent *)GetEvent())->GetTrack(trID); | |
457 | trc->ReplaceTOFClusterID(oldID,newID); | |
458 | } | |
459 | for (int it=fNTOFhits;it--;) { | |
460 | AliESDTOFHit* hit = GetTOFHit(it); | |
683f60ae | 461 | if (hit) hit->SetESDTOFClusterIndex(newID); |
2874a2f5 | 462 | } |
463 | // | |
464 | } |