]>
Commit | Line | Data |
---|---|---|
2fbc0b17 | 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 | ||
17 | //////////////////////////////////////////////// | |
18 | // Class to handle pairs of tracks | |
19 | // Useful for resonance analysis | |
20 | // Derives from AliVParticle => | |
21 | // usable in Correction Framework | |
22 | //////////////////////////////////////////////// | |
23 | // author : renaud.vernet@cern.ch | |
24 | //////////////////////////////////////////////// | |
25 | ||
26 | #include "AliCFPair.h" | |
27 | #include "AliESDtrack.h" | |
28 | #include "AliESDv0.h" | |
29 | #include "AliESDEvent.h" | |
30 | #include "TMath.h" | |
10d9a8a6 | 31 | #include "AliAODv0.h" |
2fbc0b17 | 32 | |
33 | ClassImp(AliCFPair) | |
34 | ||
10d9a8a6 | 35 | AliCFPair::AliCFPair(AliVParticle* t1, AliVParticle* t2) : |
2fbc0b17 | 36 | AliVParticle(), |
37 | fIsV0(0), | |
38 | fTrackNeg(t1), | |
39 | fTrackPos(t2), | |
10d9a8a6 | 40 | fESDV0(0x0), |
41 | fAODV0(0x0), | |
42 | fLabel(-1), | |
43 | fV0PDG(0) | |
2fbc0b17 | 44 | { |
45 | // | |
46 | // 2-track ctor | |
47 | // | |
48 | } | |
49 | AliCFPair::AliCFPair(AliESDv0* v0, AliESDEvent* esd) : | |
50 | AliVParticle(), | |
51 | fIsV0(1), | |
52 | fTrackNeg(esd->GetTrack(v0->GetNindex())), | |
53 | fTrackPos(esd->GetTrack(v0->GetPindex())), | |
10d9a8a6 | 54 | fESDV0(v0), |
55 | fAODV0(0x0), | |
56 | fLabel(-1), | |
57 | fV0PDG(0) | |
58 | { | |
59 | // | |
60 | // V0 ctor | |
61 | // | |
62 | } | |
63 | AliCFPair::AliCFPair(AliAODv0* v0) : | |
64 | AliVParticle(), | |
65 | fIsV0(1), | |
66 | fTrackNeg((AliVParticle*)v0->GetSecondaryVtx()->GetDaughter(1)), | |
67 | fTrackPos((AliVParticle*)v0->GetSecondaryVtx()->GetDaughter(0)), | |
68 | fESDV0(0x0), | |
69 | fAODV0(v0), | |
70 | fLabel(-1), | |
71 | fV0PDG(0) | |
2fbc0b17 | 72 | { |
73 | // | |
74 | // V0 ctor | |
75 | // | |
76 | } | |
77 | AliCFPair::AliCFPair(const AliCFPair& c) : | |
78 | AliVParticle(c), | |
79 | fIsV0(c.fIsV0), | |
80 | fTrackNeg(c.fTrackNeg), | |
81 | fTrackPos(c.fTrackPos), | |
10d9a8a6 | 82 | fESDV0(c.fESDV0), |
83 | fAODV0(c.fAODV0), | |
84 | fLabel(c.fLabel), | |
85 | fV0PDG(c.fV0PDG) | |
2fbc0b17 | 86 | { |
87 | // | |
88 | // Copy constructor. | |
89 | // | |
90 | } | |
91 | AliCFPair& AliCFPair::operator=(const AliCFPair& c) { | |
92 | // | |
93 | // assignment operator. | |
94 | // | |
95 | ||
96 | if (this!=&c) { | |
97 | AliVParticle::operator=(c); | |
98 | fIsV0 = c.fIsV0; | |
99 | fTrackNeg = c.fTrackNeg ; | |
100 | fTrackPos = c.fTrackPos ; | |
10d9a8a6 | 101 | fESDV0 = c.fESDV0 ; |
102 | fAODV0 = c.fAODV0 ; | |
103 | fLabel = c.fLabel ; | |
104 | fV0PDG = c.fV0PDG ; | |
2fbc0b17 | 105 | } |
106 | return *this; | |
107 | } | |
108 | Bool_t AliCFPair::PxPyPz(Double_t p[3]) const { | |
109 | // | |
110 | // sets pair total momentum in vector p | |
111 | // | |
10d9a8a6 | 112 | if (fIsV0) { |
113 | if (fESDV0) fESDV0->GetPxPyPz(p[0],p[1],p[2]); | |
114 | else if (fAODV0) fAODV0->PxPyPz(p); | |
115 | else Error("PxPyPz","Pointer to V0 not found"); | |
116 | } | |
117 | else if (fTrackNeg && fTrackPos) { | |
118 | p[0]=fTrackNeg->Px()+fTrackPos->Px(); | |
119 | p[1]=fTrackNeg->Py()+fTrackPos->Py(); | |
120 | p[2]=fTrackNeg->Pz()+fTrackPos->Pz(); | |
2fbc0b17 | 121 | } |
10d9a8a6 | 122 | else Error("PxPyPz","Could not find V0 nor track pointers"); |
2fbc0b17 | 123 | return kTRUE; |
124 | } | |
125 | ||
126 | Double32_t AliCFPair::P() const { | |
127 | // | |
128 | // returns pair total momentum norm | |
129 | // | |
130 | Double32_t mom[3]; | |
131 | PxPyPz(mom); | |
132 | return TMath::Sqrt(mom[0]*mom[0]+mom[1]*mom[1]+mom[2]*mom[2]); | |
133 | } | |
134 | ||
135 | Double32_t AliCFPair::Px() const { | |
136 | // | |
137 | // returns pair X-projected momentum | |
138 | // | |
139 | Double32_t mom[3]; | |
140 | PxPyPz(mom); | |
141 | return mom[0]; | |
142 | } | |
143 | Double32_t AliCFPair::Py() const { | |
144 | // | |
145 | // returns pair Y-projected momentum | |
146 | // | |
147 | Double32_t mom[3]; | |
148 | PxPyPz(mom); | |
149 | return mom[1]; | |
150 | } | |
151 | Double32_t AliCFPair::Pz() const { | |
152 | // | |
153 | // returns pair Z-projected momentum | |
154 | // | |
155 | Double32_t mom[3]; | |
156 | PxPyPz(mom); | |
157 | return mom[2]; | |
158 | } | |
159 | Double32_t AliCFPair::Pt() const { | |
160 | // | |
161 | // returns pair transverse (XY) momentum | |
162 | // | |
163 | Double32_t mom[3]; | |
164 | PxPyPz(mom); | |
165 | return sqrt(mom[0]*mom[0]+mom[1]*mom[1]); | |
166 | } | |
167 | Double32_t AliCFPair::E() const { | |
168 | // | |
169 | // returns pair total energy according to ESD-calculated mass | |
170 | // | |
171 | Double32_t mom[3]; | |
172 | PxPyPz(mom); | |
173 | Double32_t mass=M() ; | |
174 | return TMath::Sqrt(mass*mass + mom[0]*mom[0]+ mom[1]*mom[1]+ mom[2]*mom[2]); | |
175 | } | |
176 | Bool_t AliCFPair::XvYvZv(Double_t x[3]) const { | |
177 | // | |
178 | // sets pair position to x | |
179 | // since this class is designed for resonances, the assumed pair position | |
180 | // should be the same for both tracks. neg track position is kept here | |
181 | // | |
10d9a8a6 | 182 | |
183 | if (fIsV0) { | |
184 | if (fESDV0) fESDV0->GetXYZ(x[0],x[1],x[2]); | |
185 | else if (fAODV0) fAODV0->XvYvZv(x); | |
186 | else Error("PxPyPz","Pointer to V0 not found"); | |
2fbc0b17 | 187 | } |
10d9a8a6 | 188 | else if (fTrackNeg) fTrackNeg->PxPyPz(x); |
189 | else Error("PxPyPz","Could not find V0 nor track pointers"); | |
190 | ||
2fbc0b17 | 191 | return kTRUE; |
192 | } | |
193 | Double32_t AliCFPair::Xv() const { | |
194 | // | |
195 | // returns pair X-projected position | |
196 | // | |
197 | Double32_t pos[3]; | |
198 | XvYvZv(pos); | |
199 | return pos[0]; | |
200 | } | |
201 | Double32_t AliCFPair::Yv() const { | |
202 | // | |
203 | // returns pair Y-projected position | |
204 | // | |
205 | Double32_t pos[3]; | |
206 | XvYvZv(pos); | |
207 | return pos[1]; | |
208 | } | |
209 | Double32_t AliCFPair::Zv() const { | |
210 | // | |
211 | // returns pair Z-projected position | |
212 | // | |
213 | Double32_t pos[3]; | |
214 | XvYvZv(pos); | |
215 | return pos[2]; | |
216 | } | |
217 | Double32_t AliCFPair::Phi() const { | |
218 | // | |
219 | // returns pair phi angle (in transverse plane) | |
220 | // | |
221 | return TMath::Pi()+TMath::ATan2(-Py(),-Px()); | |
222 | } | |
223 | Double32_t AliCFPair::Theta() const { | |
224 | // | |
225 | // returns pair theta angle (in YZ plane) | |
226 | // | |
227 | return (Pz()==0)?TMath::PiOver2():TMath::ACos(Pz()/P()); | |
228 | } | |
229 | Double32_t AliCFPair::Eta() const { | |
230 | // | |
231 | // returns pair pseudo-rapidity | |
232 | // | |
233 | Double32_t pmom = P(); | |
234 | Double32_t pz = Pz(); | |
235 | if (pmom != TMath::Abs(pz)) return 0.5*TMath::Log((pmom+pz)/(pmom-pz)); | |
236 | else return 999; | |
237 | } | |
238 | Double32_t AliCFPair::Y() const { | |
239 | // | |
240 | // returns pair rapidity | |
241 | // | |
242 | Double32_t e = E(); | |
243 | Double32_t pz = Pz(); | |
244 | ||
245 | if (e == pz || e == -pz) { | |
246 | printf("GetRapidity : ERROR : rapidity for 4-vector with E = Pz -- infinite result"); | |
247 | return 999; | |
248 | } | |
249 | if (e < pz) { | |
250 | printf("GetRapidity : ERROR : rapidity for 4-vector with E = Pz -- infinite result"); | |
251 | return 999; | |
252 | } | |
253 | Double32_t y = 0.5 * log((e + pz) / (e - pz)); | |
254 | return y; | |
255 | } | |
256 | Double32_t AliCFPair::M() const { | |
257 | // | |
258 | // returns pair invariant mass | |
259 | // in case of a V0, returns the current mass hypothesis | |
260 | // otherwise returns ESD-calculated mass | |
261 | // | |
262 | ||
10d9a8a6 | 263 | Double32_t minv = 0. ; |
2fbc0b17 | 264 | |
10d9a8a6 | 265 | if (fIsV0) { |
266 | if (fESDV0) { | |
267 | fESDV0->ChangeMassHypothesis(fV0PDG); | |
268 | minv = (Double32_t)fESDV0->GetEffMass(); | |
269 | } | |
270 | else if (fAODV0) { | |
271 | switch (fV0PDG) { | |
272 | case 310 : minv = fAODV0->MassK0Short() ; break ; | |
273 | case 3122 : minv = fAODV0->MassLambda() ; break ; | |
274 | case -3122: minv = fAODV0->MassAntiLambda() ; break ; | |
275 | default: minv = -1. ; break ; | |
276 | } | |
277 | } | |
278 | else Error("PxPyPz","Pointer to V0 not found"); | |
279 | } | |
280 | else if (fTrackNeg && fTrackPos) { | |
2fbc0b17 | 281 | Double32_t p = P() ; |
282 | Double32_t e = fTrackNeg->E() + fTrackPos->E() ; | |
283 | minv = TMath::Sqrt(e*e-p*p); | |
284 | } | |
10d9a8a6 | 285 | else Error("M","Could not find V0 nor track pointers"); |
286 | ||
2fbc0b17 | 287 | return minv ; |
288 | } |