]>
Commit | Line | Data |
---|---|---|
45ee0bcc | 1 | |
2 | /************************************************************************** | |
3 | * Authors : Antonin Maire, Boris Hippolyte * | |
4 | * Contributors are mentioned in the code where appropriate. * | |
5 | * * | |
6 | * Permission to use, copy, modify and distribute this software and its * | |
7 | * documentation strictly for non-commercial purposes is hereby granted * | |
8 | * without fee, provided that the above copyright notice appears in all * | |
9 | * copies and that both the copyright notice and this permission notice * | |
10 | * appear in the supporting documentation. The authors make no claims * | |
11 | * about the suitability of this software for any purpose. It is * | |
12 | * provided "as is" without express or implied warranty. * | |
13 | **************************************************************************/ | |
14 | ||
15 | //----------------------------------------------------------------- | |
16 | // AliAnalysisTaskCheckCascade class | |
684aef2e | 17 | // This task is for QAing the Cascades from ESD and AOD |
45ee0bcc | 18 | // Origin : Antonin Maire Fev2008, antonin.maire@ires.in2p3.fr |
19 | // Modified : A.M Juillet 2008 | |
20 | //----------------------------------------------------------------- | |
21 | ||
22 | ||
23 | ||
24 | ||
25 | class TTree; | |
26 | class TParticle; | |
27 | class TVector3; | |
28 | ||
29 | //class AliMCEventHandler; | |
30 | //class AliMCEvent; | |
31 | //class AliStack; | |
32 | ||
33 | class AliESDVertex; | |
34 | class AliAODVertex; | |
35 | class AliESDv0; | |
36 | class AliAODv0; | |
37 | ||
38 | #include <iostream> | |
39 | ||
40 | #include "TList.h" | |
6dc8b253 | 41 | #include "TH1.h" |
42 | #include "TH2.h" | |
45ee0bcc | 43 | #include "TCanvas.h" |
44 | #include "TMath.h" | |
45 | ||
46 | #include "AliLog.h" | |
47 | ||
48 | #include "AliESDEvent.h" | |
49 | #include "AliAODEvent.h" | |
50 | //#include "AliCascadeVertexer.h" | |
51 | ||
52 | #include "AliESDcascade.h" | |
53 | #include "AliAODcascade.h" | |
54 | ||
55 | #include "AliAnalysisTaskCheckCascade.h" | |
56 | ||
57 | ClassImp(AliAnalysisTaskCheckCascade) | |
58 | ||
59 | ||
60 | ||
61 | //________________________________________________________________________ | |
62 | AliAnalysisTaskCheckCascade::AliAnalysisTaskCheckCascade() | |
63 | : AliAnalysisTaskSE(), fAnalysisType("ESD"), fCollidingSystems(0), | |
64 | ||
65 | // - Cascade part initialisation | |
66 | fListHistCascade(0), | |
67 | fHistTrackMultiplicity(0), fHistCascadeMultiplicity(0), | |
68 | fHistVtxStatus(0), | |
69 | ||
70 | fHistPosTrkgPrimaryVtxX(0), fHistPosTrkgPrimaryVtxY(0), fHistPosTrkgPrimaryVtxZ(0), fHistTrkgPrimaryVtxRadius(0), | |
71 | fHistPosBestPrimaryVtxX(0), fHistPosBestPrimaryVtxY(0), fHistPosBestPrimaryVtxZ(0), fHistBestPrimaryVtxRadius(0), | |
72 | f2dHistTrkgPrimVtxVsBestPrimVtx(0), | |
73 | ||
74 | fHistEffMassXi(0), fHistChi2Xi(0), | |
75 | fHistDcaXiDaughters(0), fHistDcaBachToPrimVertex(0), fHistXiCosineOfPointingAngle(0), fHistXiRadius(0), | |
76 | ||
77 | fHistMassLambdaAsCascDghter(0), | |
78 | fHistV0Chi2Xi(0), | |
79 | fHistDcaV0DaughtersXi(0), | |
80 | fHistDcaV0ToPrimVertexXi(0), | |
81 | fHistV0CosineOfPointingAngleXi(0), | |
82 | fHistV0RadiusXi(0), | |
83 | fHistDcaPosToPrimVertexXi(0), fHistDcaNegToPrimVertexXi(0), | |
84 | ||
85 | fHistMassXiMinus(0), fHistMassXiPlus(0), | |
86 | fHistMassOmegaMinus(0), fHistMassOmegaPlus(0), | |
87 | ||
88 | fHistXiTransvMom(0), fHistXiTotMom(0), | |
89 | fHistBachTransvMom(0), fHistBachTotMom(0), | |
90 | ||
91 | fHistChargeXi(0), | |
92 | fHistV0toXiCosineOfPointingAngle(0), | |
93 | ||
94 | fHistRapXi(0), fHistRapOmega(0), fHistEta(0), | |
95 | fHistTheta(0), fHistPhi(0), | |
96 | ||
97 | f2dHistArmenteros(0), | |
98 | f2dHistEffMassLambdaVsEffMassXiMinus(0), f2dHistEffMassXiVsEffMassOmegaMinus(0), | |
99 | f2dHistEffMassLambdaVsEffMassXiPlus(0), f2dHistEffMassXiVsEffMassOmegaPlus(0), | |
100 | f2dHistXiRadiusVsEffMassXiMinus(0), f2dHistXiRadiusVsEffMassXiPlus(0) | |
101 | ||
102 | { | |
103 | // Dummy Constructor | |
104 | } | |
105 | ||
106 | ||
107 | ||
108 | ||
109 | ||
110 | ||
111 | ||
112 | ||
113 | //________________________________________________________________________ | |
114 | AliAnalysisTaskCheckCascade::AliAnalysisTaskCheckCascade(const char *name) | |
115 | : AliAnalysisTaskSE(name), fAnalysisType("ESD"), fCollidingSystems(0), | |
116 | ||
117 | // - Cascade part initialisation | |
118 | fListHistCascade(0), | |
119 | fHistTrackMultiplicity(0), fHistCascadeMultiplicity(0), | |
120 | fHistVtxStatus(0), | |
121 | ||
122 | fHistPosTrkgPrimaryVtxX(0), fHistPosTrkgPrimaryVtxY(0), fHistPosTrkgPrimaryVtxZ(0), fHistTrkgPrimaryVtxRadius(0), | |
123 | fHistPosBestPrimaryVtxX(0), fHistPosBestPrimaryVtxY(0), fHistPosBestPrimaryVtxZ(0), fHistBestPrimaryVtxRadius(0), | |
124 | f2dHistTrkgPrimVtxVsBestPrimVtx(0), | |
125 | ||
126 | fHistEffMassXi(0), fHistChi2Xi(0), | |
127 | fHistDcaXiDaughters(0), fHistDcaBachToPrimVertex(0), fHistXiCosineOfPointingAngle(0), fHistXiRadius(0), | |
128 | ||
129 | fHistMassLambdaAsCascDghter(0), | |
130 | fHistV0Chi2Xi(0), | |
131 | fHistDcaV0DaughtersXi(0), | |
132 | fHistDcaV0ToPrimVertexXi(0), | |
133 | fHistV0CosineOfPointingAngleXi(0), | |
134 | fHistV0RadiusXi(0), | |
135 | fHistDcaPosToPrimVertexXi(0), fHistDcaNegToPrimVertexXi(0), | |
136 | ||
137 | fHistMassXiMinus(0), fHistMassXiPlus(0), | |
138 | fHistMassOmegaMinus(0), fHistMassOmegaPlus(0), | |
139 | ||
140 | fHistXiTransvMom(0), fHistXiTotMom(0), | |
141 | fHistBachTransvMom(0), fHistBachTotMom(0), | |
142 | ||
143 | fHistChargeXi(0), | |
144 | fHistV0toXiCosineOfPointingAngle(0), | |
145 | ||
146 | fHistRapXi(0), fHistRapOmega(0), fHistEta(0), | |
147 | fHistTheta(0), fHistPhi(0), | |
148 | ||
149 | f2dHistArmenteros(0), | |
150 | f2dHistEffMassLambdaVsEffMassXiMinus(0), f2dHistEffMassXiVsEffMassOmegaMinus(0), | |
151 | f2dHistEffMassLambdaVsEffMassXiPlus(0), f2dHistEffMassXiVsEffMassOmegaPlus(0), | |
152 | f2dHistXiRadiusVsEffMassXiMinus(0), f2dHistXiRadiusVsEffMassXiPlus(0) | |
153 | ||
154 | ||
155 | ||
156 | { | |
157 | // Constructor | |
158 | ||
159 | // Define input and output slots here | |
160 | // Input slot #0 works with a TChain | |
161 | ||
162 | // Output slot #0 writes into a TList container (Cascade) | |
163 | DefineOutput(1, TList::Class()); | |
164 | } | |
165 | ||
166 | ||
167 | ||
168 | ||
169 | ||
170 | ||
171 | //________________________________________________________________________ | |
172 | void AliAnalysisTaskCheckCascade::UserCreateOutputObjects() | |
173 | { | |
174 | // Create histograms | |
175 | // Called once | |
176 | ||
177 | ||
178 | ||
179 | fListHistCascade = new TList(); | |
180 | ||
181 | ||
182 | // - General histos | |
183 | ||
184 | if(! fHistTrackMultiplicity) { | |
185 | if(fCollidingSystems)// AA collisions | |
186 | fHistTrackMultiplicity = new TH1F("fHistTrackMultiplicity", | |
187 | "Multiplicity distribution;Number of tracks;Events", | |
188 | 200, 0, 40000); | |
189 | else // pp collisions | |
190 | fHistTrackMultiplicity = new TH1F("fHistTrackMultiplicity", | |
191 | "Track Multiplicity;Nbr of tracks/Evt;Events", | |
192 | 200, 0, 200); | |
193 | fListHistCascade->Add(fHistTrackMultiplicity); | |
194 | } | |
195 | ||
196 | if(! fHistCascadeMultiplicity) { | |
197 | if(fCollidingSystems)// AA collisions | |
198 | fHistCascadeMultiplicity = new TH1F("fHistCascadeMultiplicity", | |
199 | "Multiplicity distribution;Number of Cascades;Events", | |
200 | 25, 0, 25); | |
201 | else // pp collisions | |
202 | fHistCascadeMultiplicity = new TH1F("fHistCascadeMultiplicity", | |
203 | "Cascades per event;Nbr of Cascades/Evt;Events", | |
204 | 10, 0, 10); | |
205 | fListHistCascade->Add(fHistCascadeMultiplicity); | |
206 | } | |
207 | ||
208 | ||
209 | ||
210 | if(! fHistVtxStatus ){ | |
211 | fHistVtxStatus = new TH1F( "fHistVtxStatus" , "Does a Trckg Prim.vtx exist ?; true=1 or false=0; Nb of Events" , 4, -1.0, 3.0 ); | |
212 | fListHistCascade->Add(fHistVtxStatus); | |
213 | } | |
214 | ||
215 | ||
216 | ||
217 | ||
218 | ||
219 | ||
220 | // - Vertex Positions | |
221 | ||
222 | if(! fHistPosTrkgPrimaryVtxX ){ | |
223 | fHistPosTrkgPrimaryVtxX = new TH1F( "fHistPosTrkgPrimaryVtxX" , "Trkg Prim. Vertex Position in x; x (cm); Events" , 200, -0.5, 0.5 ); | |
224 | fListHistCascade->Add(fHistPosTrkgPrimaryVtxX); | |
225 | } | |
226 | ||
227 | ||
228 | if(! fHistPosTrkgPrimaryVtxY){ | |
229 | fHistPosTrkgPrimaryVtxY = new TH1F( "fHistPosTrkgPrimaryVtxY" , "Trkg Prim. Vertex Position in y; y (cm); Events" , 200, -0.5, 0.5 ); | |
230 | fListHistCascade->Add(fHistPosTrkgPrimaryVtxY); | |
231 | } | |
232 | ||
233 | if(! fHistPosTrkgPrimaryVtxZ ){ | |
234 | fHistPosTrkgPrimaryVtxZ = new TH1F( "fHistPosTrkgPrimaryVtxZ" , "Trkg Prim. Vertex Position in z; z (cm); Events" , 100, -15.0, 15.0 ); | |
235 | fListHistCascade->Add(fHistPosTrkgPrimaryVtxZ); | |
236 | } | |
237 | ||
238 | if(! fHistTrkgPrimaryVtxRadius ){ | |
239 | fHistTrkgPrimaryVtxRadius = new TH1F( "fHistTrkgPrimaryVtxRadius", "Trkg Prim. Vertex radius; r (cm); Events" , 150, 0., 15.0 ); | |
240 | fListHistCascade->Add(fHistTrkgPrimaryVtxRadius); | |
241 | } | |
242 | ||
243 | ||
244 | ||
245 | ||
246 | if(! fHistPosBestPrimaryVtxX ){ | |
247 | fHistPosBestPrimaryVtxX = new TH1F( "fHistPosBestPrimaryVtxX" , "Best Prim. Vertex Position in x; x (cm); Events" , 200, -0.5, 0.5 ); | |
248 | fListHistCascade->Add(fHistPosBestPrimaryVtxX); | |
249 | } | |
250 | ||
251 | if(! fHistPosBestPrimaryVtxY){ | |
252 | fHistPosBestPrimaryVtxY = new TH1F( "fHistPosBestPrimaryVtxY" , "Best Prim. Vertex Position in y; y (cm); Events" , 200, -0.5, 0.5 ); | |
253 | fListHistCascade->Add(fHistPosBestPrimaryVtxY); | |
254 | } | |
255 | ||
256 | if(! fHistPosBestPrimaryVtxZ ){ | |
257 | fHistPosBestPrimaryVtxZ = new TH1F( "fHistPosBestPrimaryVtxZ" , "Best Prim. Vertex Position in z; z (cm); Events" , 100, -15.0, 15.0 ); | |
258 | fListHistCascade->Add(fHistPosBestPrimaryVtxZ); | |
259 | } | |
260 | ||
261 | if(! fHistBestPrimaryVtxRadius ){ | |
262 | fHistBestPrimaryVtxRadius = new TH1F( "fHistBestPrimaryVtxRadius", "Best Prim. vertex radius; r (cm); Events" , 150, 0., 15.0 ); | |
263 | fListHistCascade->Add(fHistBestPrimaryVtxRadius); | |
264 | } | |
265 | ||
266 | if(! f2dHistTrkgPrimVtxVsBestPrimVtx) { | |
267 | f2dHistTrkgPrimVtxVsBestPrimVtx = new TH2F( "f2dHistTrkgPrimVtxVsBestPrimVtx", "r_{Trck Prim. Vtx} Vs r_{Best Prim. Vtx}; r_{Track Vtx} (cm); r_{Best Vtx} (cm)", 300, 0., 15.0, 300, 0., 15.); | |
268 | fListHistCascade->Add(f2dHistTrkgPrimVtxVsBestPrimVtx); | |
269 | } | |
270 | ||
271 | ||
272 | ||
273 | ||
274 | // - Typical histos for cascades | |
275 | ||
276 | ||
277 | if(! fHistEffMassXi) { | |
278 | fHistEffMassXi = new TH1F("fHistEffMassXi", "Cascade candidates ; Invariant Mass (GeV/c^{2}) ; Counts", 200, 1.2, 2.0); | |
279 | fListHistCascade->Add(fHistEffMassXi); | |
280 | } | |
281 | ||
282 | if(! fHistChi2Xi ){ | |
283 | fHistChi2Xi = new TH1F("fHistChi2Xi", "Cascade #chi^{2}; #chi^{2}; Number of Cascades", 160, 0, 40); | |
284 | fListHistCascade->Add(fHistChi2Xi); | |
285 | } | |
286 | ||
287 | if(! fHistDcaXiDaughters ){ | |
288 | fHistDcaXiDaughters = new TH1F( "fHistDcaXiDaughters", "DCA between Xi Daughters; DCA (cm) ; Number of Cascades", 100, 0., 0.5); | |
289 | fListHistCascade->Add(fHistDcaXiDaughters); | |
290 | } | |
291 | ||
292 | if(! fHistDcaBachToPrimVertex) { | |
293 | fHistDcaBachToPrimVertex = new TH1F("fHistDcaBachToPrimVertex", "DCA of Bach. to Prim. Vertex;DCA (cm);Number of Cascades", 250, 0., 0.25); | |
294 | fListHistCascade->Add(fHistDcaBachToPrimVertex); | |
295 | } | |
296 | ||
297 | if(! fHistXiCosineOfPointingAngle) { | |
298 | fHistXiCosineOfPointingAngle = new TH1F("fHistXiCosineOfPointingAngle", "Cosine of Xi Pointing Angle; Cos (Xi Point.Angl);Number of Xis", 200, 0.98, 1.0); | |
299 | fListHistCascade->Add(fHistXiCosineOfPointingAngle); | |
300 | } | |
301 | ||
302 | if(! fHistXiRadius ){ | |
303 | fHistXiRadius = new TH1F( "fHistXiRadius", "Casc. decay transv. radius; r (cm); Counts" , 200, 0., 20.0 ); | |
304 | fListHistCascade->Add(fHistXiRadius); | |
305 | } | |
306 | ||
307 | ||
308 | // - Histos about ~ the "V0 part" of the cascade, coming by inheritance from AliESDv0 | |
309 | ||
310 | ||
311 | ||
312 | if (! fHistMassLambdaAsCascDghter) { | |
313 | fHistMassLambdaAsCascDghter = new TH1F("fHistMassLambdaAsCascDghter","#Lambda associated to Casc. candidates;Eff. Mass (GeV/c^{2});Counts", 160,1.00,1.8); | |
314 | fListHistCascade->Add(fHistMassLambdaAsCascDghter); | |
315 | } | |
316 | ||
317 | if (! fHistV0Chi2Xi) { | |
318 | fHistV0Chi2Xi = new TH1F("fHistV0Chi2Xi", "V0 #chi^{2}, in cascade; #chi^{2};Counts", 160, 0, 40); | |
319 | fListHistCascade->Add(fHistV0Chi2Xi); | |
320 | } | |
321 | ||
322 | if (! fHistDcaV0DaughtersXi) { | |
323 | fHistDcaV0DaughtersXi = new TH1F("fHistDcaV0DaughtersXi", "DCA between V0 daughters, in cascade;DCA (cm);Number of V0s", 120, 0., 0.6); | |
324 | fListHistCascade->Add(fHistDcaV0DaughtersXi); | |
325 | } | |
326 | ||
327 | if (! fHistDcaV0ToPrimVertexXi) { | |
328 | fHistDcaV0ToPrimVertexXi = new TH1F("fHistDcaV0ToPrimVertexXi", "DCA of V0 to Prim. Vertex, in cascade;DCA (cm);Number of Cascades", 200, 0., 1.); | |
329 | fListHistCascade->Add(fHistDcaV0ToPrimVertexXi); | |
330 | } | |
331 | ||
332 | if (! fHistV0CosineOfPointingAngleXi) { | |
333 | fHistV0CosineOfPointingAngleXi = new TH1F("fHistV0CosineOfPointingAngleXi", "Cosine of V0 Pointing Angle, in cascade;Cos(V0 Point. Angl); Counts", 200, 0.98, 1.0); | |
334 | fListHistCascade->Add(fHistV0CosineOfPointingAngleXi); | |
335 | } | |
336 | ||
337 | if (! fHistV0RadiusXi) { | |
338 | fHistV0RadiusXi = new TH1F("fHistV0RadiusXi", "V0 decay radius, in cascade; radius (cm); Counts", 200, 0, 20); | |
339 | fListHistCascade->Add(fHistV0RadiusXi); | |
340 | } | |
341 | ||
342 | if (! fHistDcaPosToPrimVertexXi) { | |
343 | fHistDcaPosToPrimVertexXi = new TH1F("fHistDcaPosToPrimVertexXi", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Counts", 300, 0, 3); | |
344 | fListHistCascade->Add(fHistDcaPosToPrimVertexXi); | |
345 | } | |
346 | ||
347 | if (! fHistDcaNegToPrimVertexXi) { | |
348 | fHistDcaNegToPrimVertexXi = new TH1F("fHistDcaNegToPrimVertexXi", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Counts", 300, 0, 3); | |
349 | fListHistCascade->Add(fHistDcaNegToPrimVertexXi); | |
350 | } | |
351 | ||
352 | ||
353 | ||
354 | ||
355 | // - Effective mass histos for cascades. | |
356 | ||
357 | if (! fHistMassXiMinus) { | |
358 | fHistMassXiMinus = new TH1F("fHistMassXiMinus","#Xi^{-} candidates;M( #Lambda , #pi^{-} ) (GeV/c^{2});Counts", 200,1.2,2.0); | |
359 | fListHistCascade->Add(fHistMassXiMinus); | |
360 | } | |
361 | ||
362 | if (! fHistMassXiPlus) { | |
363 | fHistMassXiPlus = new TH1F("fHistMassXiPlus","#Xi^{+} candidates;M( #bar{#Lambda}^{0} , #pi^{+} ) (GeV/c^{2});Counts",200,1.2,2.0); | |
364 | fListHistCascade->Add(fHistMassXiPlus); | |
365 | } | |
366 | ||
367 | if (! fHistMassOmegaMinus) { | |
368 | fHistMassOmegaMinus = new TH1F("fHistMassOmegaMinus","#Omega^{-} candidates;M( #Lambda , K^{-} ) (GeV/c^{2});Counts", 250,1.5,2.5); | |
369 | fListHistCascade->Add(fHistMassOmegaMinus); | |
370 | } | |
371 | ||
372 | if (! fHistMassOmegaPlus) { | |
373 | fHistMassOmegaPlus = new TH1F("fHistMassOmegaPlus","#Omega^{+} candidates;M( #bar{#Lambda}^{0} , K^{+} ) (GeV/c^{2});Counts", 250,1.5,2.5); | |
374 | fListHistCascade->Add(fHistMassOmegaPlus); | |
375 | } | |
376 | ||
377 | ||
378 | ||
379 | // - Complements for QA | |
380 | ||
381 | if(! fHistXiTransvMom ){ | |
382 | fHistXiTransvMom = new TH1F( "fHistXiTransvMom" , "Xi transverse momentum ; p_{t}(#Xi) (GeV/c); Counts", 100, 0.0, 10.0); | |
383 | fListHistCascade->Add(fHistXiTransvMom); | |
384 | } | |
385 | ||
386 | if(! fHistXiTotMom ){ | |
387 | fHistXiTotMom = new TH1F( "fHistXiTotMom" , "Xi momentum norm; p_{tot}(#Xi) (GeV/c); Counts", 150, 0.0, 15.0); | |
388 | fListHistCascade->Add(fHistXiTotMom); | |
389 | } | |
390 | ||
391 | ||
392 | if(! fHistBachTransvMom ){ | |
393 | fHistBachTransvMom = new TH1F( "fHistBachTransvMom" , "Bach. transverse momentum ; p_{t}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0); | |
394 | fListHistCascade->Add(fHistBachTransvMom); | |
395 | } | |
396 | ||
397 | if(! fHistBachTotMom ){ | |
398 | fHistBachTotMom = new TH1F( "fHistBachTotMom" , "Bach. momentum norm; p_{tot}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0); | |
399 | fListHistCascade->Add(fHistBachTotMom); | |
400 | } | |
401 | ||
402 | ||
403 | if(! fHistChargeXi ){ | |
404 | fHistChargeXi = new TH1F( "fHistChargeXi" , "Charge of casc. candidates ; Sign ; Counts", 5, -2.0, 3.0); | |
405 | fListHistCascade->Add(fHistChargeXi); | |
406 | } | |
407 | ||
408 | ||
409 | if (! fHistV0toXiCosineOfPointingAngle) { | |
410 | fHistV0toXiCosineOfPointingAngle = new TH1F("fHistV0toXiCosineOfPointingAngle", "Cos. of V0 Ptng Angl / Xi vtx ;Cos(V0 Point. Angl / Xi vtx); Counts", 100, 0.99, 1.0); | |
411 | fListHistCascade->Add(fHistV0toXiCosineOfPointingAngle); | |
412 | } | |
413 | ||
414 | ||
415 | if(! fHistRapXi ){ | |
416 | fHistRapXi = new TH1F( "fHistRapXi" , "Rapidity of Xi candidates ; y ; Counts", 200, -5.0, 5.0); | |
417 | fListHistCascade->Add(fHistRapXi); | |
418 | } | |
419 | ||
420 | if(! fHistRapOmega ){ | |
421 | fHistRapOmega = new TH1F( "fHistRapOmega" , "Rapidity of Omega candidates ; y ; Counts", 200, -5.0, 5.0); | |
422 | fListHistCascade->Add(fHistRapOmega); | |
423 | } | |
424 | ||
425 | if(! fHistEta ){ | |
426 | fHistEta = new TH1F( "fHistEta" , "Pseudo-rap. of casc. candidates ; #eta ; Counts", 120, -3.0, 3.0); | |
427 | fListHistCascade->Add(fHistEta); | |
428 | } | |
429 | ||
430 | if(! fHistTheta ){ | |
431 | fHistTheta = new TH1F( "fHistTheta" , "#theta of casc. candidates ; #theta (deg) ; Counts", 180, 0., 180.0); | |
432 | fListHistCascade->Add(fHistTheta); | |
433 | } | |
434 | ||
435 | if(! fHistPhi ){ | |
436 | fHistPhi = new TH1F( "fHistPhi" , "#phi of casc. candidates ; #phi (deg) ; Counts", 360, 0., 360.); | |
437 | fListHistCascade->Add(fHistPhi); | |
438 | } | |
439 | ||
440 | ||
441 | if(! f2dHistArmenteros) { | |
442 | f2dHistArmenteros = new TH2F( "f2dHistArmenteros", "#alpha_{Arm}(casc. cand.) Vs Pt_{Arm}(casc. cand.); #alpha_{Arm} ; Pt_{Arm} (GeV/c)", 140, -1.2, 1.2, 300, 0., 0.3); | |
443 | fListHistCascade->Add(f2dHistArmenteros); | |
444 | } | |
445 | ||
446 | if(! f2dHistEffMassLambdaVsEffMassXiMinus) { | |
447 | f2dHistEffMassLambdaVsEffMassXiMinus = new TH2F( "f2dHistEffMassLambdaVsEffMassXiMinus", "M_{#Lambda} Vs M_{#Xi^{-} candidates} ; Inv. M_{#Lambda^{0}} (GeV/c^{2}) ; M( #Lambda , #pi^{-} ) (GeV/c^{2})", 300, 1.1,1.13, 200, 1.2, 2.0); | |
448 | fListHistCascade->Add(f2dHistEffMassLambdaVsEffMassXiMinus); | |
449 | } | |
450 | ||
451 | if(! f2dHistEffMassXiVsEffMassOmegaMinus) { | |
452 | f2dHistEffMassXiVsEffMassOmegaMinus = new TH2F( "f2dHistEffMassXiVsEffMassOmegaMinus", "M_{#Xi^{-} candidates} Vs M_{#Omega^{-} candidates} ; M( #Lambda , #pi^{-} ) (GeV/c^{2}) ; M( #Lambda , K^{-} ) (GeV/c^{2})", 200, 1.2, 2.0, 250, 1.5, 2.5); | |
453 | fListHistCascade->Add(f2dHistEffMassXiVsEffMassOmegaMinus); | |
454 | } | |
455 | ||
456 | if(! f2dHistEffMassLambdaVsEffMassXiPlus) { | |
457 | f2dHistEffMassLambdaVsEffMassXiPlus = new TH2F( "f2dHistEffMassLambdaVsEffMassXiPlus", "M_{#Lambda} Vs M_{#Xi^{+} candidates} ; Inv. M_{#Lambda^{0}} (GeV/c^{2}) ; M( #Lambda , #pi^{+} ) (GeV/c^{2})", 300, 1.1,1.13, 200, 1.2, 2.0); | |
458 | fListHistCascade->Add(f2dHistEffMassLambdaVsEffMassXiPlus); | |
459 | } | |
460 | ||
461 | if(! f2dHistEffMassXiVsEffMassOmegaPlus) { | |
462 | f2dHistEffMassXiVsEffMassOmegaPlus = new TH2F( "f2dHistEffMassXiVsEffMassOmegaPlus", "M_{#Xi^{+} candidates} Vs M_{#Omega^{+} candidates} ; M( #Lambda , #pi^{+} ) (GeV/c^{2}) ; M( #Lambda , K^{+} ) (GeV/c^{2})", 200, 1.2, 2.0, 250, 1.5, 2.5); | |
463 | fListHistCascade->Add(f2dHistEffMassXiVsEffMassOmegaPlus); | |
464 | } | |
465 | ||
466 | if(! f2dHistXiRadiusVsEffMassXiMinus) { | |
467 | f2dHistXiRadiusVsEffMassXiMinus = new TH2F( "f2dHistXiRadiusVsEffMassXiMinus", "Transv. R_{Xi Decay} Vs M_{#Xi^{-} candidates}; r_{Xi} (cm); M( #Lambda , #pi^{-} ) (GeV/c^{2}) ", 450, 0., 45.0, 200, 1.2, 2.0); | |
468 | fListHistCascade->Add(f2dHistXiRadiusVsEffMassXiMinus); | |
469 | } | |
470 | ||
471 | if(! f2dHistXiRadiusVsEffMassXiPlus) { | |
472 | f2dHistXiRadiusVsEffMassXiPlus = new TH2F( "f2dHistXiRadiusVsEffMassXiPlus", "Transv. R_{Xi Decay} Vs M_{#Xi^{+} candidates}; r_{Xi} (cm); M( #Lambda , #pi^{+} ) (GeV/c^{2}) ", 450, 0., 45.0, 200, 1.2, 2.0); | |
473 | fListHistCascade->Add(f2dHistXiRadiusVsEffMassXiPlus); | |
474 | } | |
475 | ||
476 | ||
477 | ||
478 | ||
479 | }// end UserCreateOutputObjects | |
480 | ||
481 | ||
482 | ||
483 | ||
484 | ||
485 | ||
486 | //________________________________________________________________________ | |
487 | void AliAnalysisTaskCheckCascade::UserExec(Option_t *) | |
488 | { | |
489 | // Main loop | |
490 | // Called for each event | |
491 | ||
492 | AliESDEvent *lESDevent = 0x0; | |
493 | AliAODEvent *lAODevent = 0x0; | |
494 | Int_t ncascades = -1; | |
495 | ||
496 | ||
497 | // Connect to the InputEvent | |
498 | // After these lines, we should have an ESD/AOD event + the number of cascades in it. | |
499 | ||
500 | if(fAnalysisType == "ESD"){ | |
501 | lESDevent = dynamic_cast<AliESDEvent*>( InputEvent() ); | |
502 | if (!lESDevent) { | |
503 | Printf("ERROR: lESDevent not available \n"); | |
504 | return; | |
505 | } | |
506 | ncascades = lESDevent->GetNumberOfCascades(); | |
507 | } | |
508 | ||
509 | if(fAnalysisType == "AOD"){ | |
510 | lAODevent = dynamic_cast<AliAODEvent*>( InputEvent() ); | |
511 | if (!lAODevent) { | |
512 | Printf("ERROR: lAODevent not available \n"); | |
513 | return; | |
514 | } | |
515 | ncascades = lAODevent->GetNumberOfCascades(); | |
516 | } | |
517 | ||
518 | // --------------------------------------------------------------- | |
519 | // I - Initialisation of the local variables that will be needed | |
520 | ||
521 | ||
522 | // - 0th part of initialisation : around primary vertex ... | |
523 | Short_t lStatusTrackingPrimVtx = -2; | |
524 | Double_t lTrkgPrimaryVtxPos[3] = {-100.0, -100.0, -100.0}; | |
525 | Double_t lTrkgPrimaryVtxRadius3D = -500.0; | |
526 | ||
527 | Double_t lBestPrimaryVtxPos[3] = {-100.0, -100.0, -100.0}; | |
528 | Double_t lBestPrimaryVtxRadius3D = -500.0; | |
529 | ||
530 | // - 1st part of initialisation : variables needed to store AliESDCascade data members | |
531 | Double_t lEffMassXi = 0. ; | |
532 | Double_t lChi2Xi = 0. ; | |
533 | Double_t lDcaXiDaughters = 0. ; | |
534 | Double_t lXiCosineOfPointingAngle = 0. ; | |
535 | Double_t lPosXi[3] = { -1000.0, -1000.0, -1000.0 }; | |
536 | Double_t lXiRadius = 0. ; | |
537 | ||
538 | ||
539 | // - 2nd part of initialisation : about V0 part in cascades | |
540 | ||
541 | Double_t lInvMassLambdaAsCascDghter = 0.; | |
542 | Double_t lV0Chi2Xi = 0. ; | |
543 | Double_t lDcaV0DaughtersXi = 0.; | |
544 | ||
545 | Double_t lDcaBachToPrimVertexXi = 0., lDcaV0ToPrimVertexXi = 0.; | |
546 | Double_t lDcaPosToPrimVertexXi = 0.; | |
547 | Double_t lDcaNegToPrimVertexXi = 0.; | |
548 | Double_t lV0CosineOfPointingAngleXi = 0. ; | |
549 | Double_t lPosV0Xi[3] = { -1000. , -1000., -1000. }; // Position of VO coming from cascade | |
550 | Double_t lV0RadiusXi = -1000.0; | |
551 | Double_t lV0quality = 0.; | |
552 | ||
553 | ||
554 | // - 3rd part of initialisation : Effective masses | |
555 | ||
556 | Double_t lInvMassXiMinus = 0.; | |
557 | Double_t lInvMassXiPlus = 0.; | |
558 | Double_t lInvMassOmegaMinus = 0.; | |
559 | Double_t lInvMassOmegaPlus = 0.; | |
560 | ||
561 | ||
562 | // - 4th part of initialisation : extra info for QA | |
563 | ||
564 | Double_t lXiMomX = 0., lXiMomY = 0., lXiMomZ = 0.; | |
565 | Double_t lXiTransvMom = 0. ; | |
566 | Double_t lXiTotMom = 0. ; | |
567 | ||
568 | Double_t lBachMomX = 0., lBachMomY = 0., lBachMomZ = 0.; | |
569 | Double_t lBachTransvMom = 0.; | |
570 | Double_t lBachTotMom = 0.; | |
571 | ||
572 | Short_t lChargeXi = -2; | |
573 | Double_t lV0toXiCosineOfPointingAngle = 0. ; | |
574 | ||
575 | Double_t lRapXi = -20.0, lRapOmega = -20.0, lEta = -20.0, lTheta = 360., lPhi = 720. ; | |
576 | Double_t lAlphaXi = -200., lPtArmXi = -200.0; | |
577 | ||
578 | ||
579 | ||
580 | //------------------------------------------------- | |
581 | // O - Cascade vertexer (ESD) | |
582 | ||
583 | // if(fAnalysisType == "ESD" ){ | |
584 | // lESDevent->ResetCascades(); | |
585 | // AliCascadeVertexer CascVtxer; | |
586 | // CascVtxer.V0sTracks2CascadeVertices(lESDevent); | |
587 | // } | |
588 | ||
589 | ||
590 | // --------------------------------------------------------------- | |
591 | // I - General histos (filled for any event) - (ESD) | |
592 | ||
593 | fHistTrackMultiplicity ->Fill( (InputEvent())->GetNumberOfTracks() ); | |
594 | fHistCascadeMultiplicity->Fill( ncascades ); | |
595 | ||
596 | ||
597 | ||
598 | ||
599 | for (Int_t iXi = 0; iXi < ncascades; iXi++) | |
600 | {// This is the begining of the Cascade loop (ESD or AOD) | |
601 | ||
602 | ||
603 | if(fAnalysisType == "ESD"){ | |
604 | ||
605 | // ------------------------------------- | |
606 | // II - Calcultaion Part dedicated to Xi vertices (ESD) | |
607 | ||
608 | AliESDcascade *xi = lESDevent->GetCascade(iXi); | |
609 | if (!xi) continue; | |
610 | ||
611 | // Just to know which file is currently open : locate the file containing Xi | |
612 | // cout << "Name of the file containing Xi candidate(s) :" | |
613 | // << fInputHandler->GetTree()->GetCurrentFile()->GetName() | |
614 | // << endl; | |
615 | ||
616 | ||
617 | // - II.Step 1 : Characteristics of the event : prim. Vtx + magnetic field (ESD) | |
618 | //------------- | |
619 | ||
620 | // For new code (v4-16-Release-Rev06 or trunk) | |
621 | ||
622 | const AliESDVertex *lPrimaryTrackingVtx = lESDevent->GetPrimaryVertexTracks(); | |
623 | // get the vtx stored in ESD found with tracks | |
624 | ||
625 | lPrimaryTrackingVtx->GetXYZ( lTrkgPrimaryVtxPos ); | |
626 | lTrkgPrimaryVtxRadius3D = TMath::Sqrt( lTrkgPrimaryVtxPos[0] * lTrkgPrimaryVtxPos[0] + | |
627 | lTrkgPrimaryVtxPos[1] * lTrkgPrimaryVtxPos[1] + | |
628 | lTrkgPrimaryVtxPos[2] * lTrkgPrimaryVtxPos[2] ); | |
629 | ||
630 | lStatusTrackingPrimVtx = lPrimaryTrackingVtx->GetStatus(); | |
631 | ||
632 | ||
633 | const AliESDVertex *lPrimaryBestVtx = lESDevent->GetPrimaryVertex(); | |
634 | // get the best primary vertex available for the event | |
635 | // As done in AliCascadeVertexer, we keep the one which is the best one available. | |
636 | // between : Tracking vertex > SPD vertex > TPC vertex > default SPD vertex | |
637 | // This one will be used for next calculations (DCA essentially) | |
638 | ||
639 | lPrimaryBestVtx->GetXYZ( lBestPrimaryVtxPos ); | |
640 | lBestPrimaryVtxRadius3D = TMath::Sqrt( lBestPrimaryVtxPos[0] * lBestPrimaryVtxPos[0] + | |
641 | lBestPrimaryVtxPos[1] * lBestPrimaryVtxPos[1] + | |
642 | lBestPrimaryVtxPos[2] * lBestPrimaryVtxPos[2] ); | |
643 | ||
644 | ||
645 | // For older evts | |
646 | ||
647 | // const AliESDVertex *lPrimaryTrackingVtx = lESDevent->GetPrimaryVertexTracks(); | |
648 | // get the vtx stored in ESD found with tracks | |
649 | // Double_t lTrkgPrimaryVtxPos[3] = {-100.0, -100.0, -100.0}; | |
650 | // lPrimaryTrackingVtx->GetXYZ( lTrkgPrimaryVtxPos ); | |
651 | // Double_t lTrkgPrimaryVtxRadius3D = TMath::Sqrt( lTrkgPrimaryVtxPos[0]*lTrkgPrimaryVtxPos[0] + | |
652 | // lTrkgPrimaryVtxPos[1] * lTrkgPrimaryVtxPos[1] + | |
653 | // lTrkgPrimaryVtxPos[2] * lTrkgPrimaryVtxPos[2] ); | |
654 | // | |
655 | // const AliESDVertex *lPrimarySPDVtx = lESDevent->GetPrimaryVertexSPD(); | |
656 | // get the vtx found by exclusive use of SPD | |
657 | // Double_t lSPDPrimaryVtxPos[3] = {-100.0, -100.0, -100.0}; | |
658 | // lPrimarySPDVtx->GetXYZ( lSPDPrimaryVtxPos ); | |
659 | // | |
660 | // // As done in AliCascadeVertexer, we keep, between both retrieved vertices, | |
661 | // // the one which is the best one available. | |
662 | // // This one will be used for next calculations (DCA essentially) | |
663 | // | |
664 | // Double_t lBestPrimaryVtxPos[3] = {-100.0, -100.0, -100.0}; | |
665 | // if( lPrimaryTrackingVtx->GetStatus() ) { // if tracking vtx = ok | |
666 | // lBestPrimaryVtxPos[0] = lTrkgPrimaryVtxPos[0]; | |
667 | // lBestPrimaryVtxPos[1] = lTrkgPrimaryVtxPos[1]; | |
668 | // lBestPrimaryVtxPos[2] = lTrkgPrimaryVtxPos[2]; | |
669 | // } | |
670 | // else{ | |
671 | // lBestPrimaryVtxPos[0] = lSPDPrimaryVtxPos[0]; | |
672 | // lBestPrimaryVtxPos[1] = lSPDPrimaryVtxPos[1]; | |
673 | // lBestPrimaryVtxPos[2] = lSPDPrimaryVtxPos[2]; | |
674 | // } | |
675 | // | |
676 | // Double_t lBestPrimaryVtxRadius3D = TMath::Sqrt( lBestPrimaryVtxPos[0]*lBestPrimaryVtxPos[0] + | |
677 | // lBestPrimaryVtxPos[1] * lBestPrimaryVtxPos[1] + | |
678 | // lBestPrimaryVtxPos[2] * lBestPrimaryVtxPos[2] ); | |
679 | ||
680 | // Back to normal | |
681 | ||
682 | Double_t lMagneticField = lESDevent->GetMagneticField( ); | |
683 | ||
684 | ||
685 | ||
686 | // - II.Step 2 : Assigning the necessary variables for specific AliESDcascade data members (ESD) | |
687 | //------------- | |
688 | lV0quality = 0.; | |
689 | xi->ChangeMassHypothesis(lV0quality , 3312); // default working hypothesis : cascade = Xi- decay | |
690 | ||
691 | lEffMassXi = xi->GetEffMassXi(); | |
692 | lChi2Xi = xi->GetChi2Xi(); | |
693 | lDcaXiDaughters = xi->GetDcaXiDaughters(); | |
694 | lXiCosineOfPointingAngle = xi->GetCascadeCosineOfPointingAngle( lBestPrimaryVtxPos[0], | |
695 | lBestPrimaryVtxPos[1], | |
696 | lBestPrimaryVtxPos[2] ); | |
697 | // Take care : the best available vertex should be used (like in AliCascadeVertexer) | |
698 | ||
699 | xi->GetXYZcascade( lPosXi[0], lPosXi[1], lPosXi[2] ); | |
700 | lXiRadius = TMath::Sqrt( lPosXi[0]*lPosXi[0] + lPosXi[1]*lPosXi[1] ); | |
701 | ||
702 | ||
703 | ||
704 | // - II.Step 3 : around the tracks : Bach + V0 (ESD) | |
705 | // ~ Necessary variables for ESDcascade data members coming from the ESDv0 part (inheritance) | |
706 | //------------- | |
707 | ||
708 | UInt_t lIdxPosXi = (UInt_t) TMath::Abs( xi->GetPindex() ); | |
709 | UInt_t lIdxNegXi = (UInt_t) TMath::Abs( xi->GetNindex() ); | |
710 | UInt_t lBachIdx = (UInt_t) TMath::Abs( xi->GetBindex() ); | |
711 | // Care track label can be negative in MC production (linked with the track quality) | |
712 | // However = normally, not the case for track index ... | |
713 | ||
714 | AliESDtrack *pTrackXi = lESDevent->GetTrack( lIdxPosXi ); | |
715 | AliESDtrack *nTrackXi = lESDevent->GetTrack( lIdxNegXi ); | |
716 | AliESDtrack *bachTrackXi = lESDevent->GetTrack( lBachIdx ); | |
717 | if (!pTrackXi || !nTrackXi || !bachTrackXi ) { | |
718 | Printf("ERROR: Could not retrieve one of the 3 daughter tracks of the cascade ..."); | |
719 | continue; | |
720 | } | |
721 | ||
722 | lInvMassLambdaAsCascDghter = xi->GetEffMass(); | |
723 | // This value shouldn't change, whatever the working hyp. is : Xi-, Xi+, Omega-, Omega+ | |
724 | lDcaV0DaughtersXi = xi->GetDcaV0Daughters(); | |
725 | lV0Chi2Xi = xi->GetChi2V0(); | |
726 | ||
727 | lV0CosineOfPointingAngleXi = xi->GetV0CosineOfPointingAngle( lBestPrimaryVtxPos[0], | |
728 | lBestPrimaryVtxPos[1], | |
729 | lBestPrimaryVtxPos[2] ); | |
730 | ||
731 | lDcaV0ToPrimVertexXi = xi->GetD( lBestPrimaryVtxPos[0], | |
732 | lBestPrimaryVtxPos[1], | |
733 | lBestPrimaryVtxPos[2] ); | |
734 | ||
735 | lDcaBachToPrimVertexXi = TMath::Abs( bachTrackXi->GetD( lBestPrimaryVtxPos[0], | |
736 | lBestPrimaryVtxPos[1], | |
737 | lMagneticField ) ); | |
738 | // Note : AliExternalTrackParam::GetD returns an algebraic value ... | |
739 | ||
740 | xi->GetXYZ( lPosV0Xi[0], lPosV0Xi[1], lPosV0Xi[2] ); | |
741 | lV0RadiusXi = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0] + lPosV0Xi[1]*lPosV0Xi[1] ); | |
742 | ||
743 | lDcaPosToPrimVertexXi = TMath::Abs( pTrackXi ->GetD( lBestPrimaryVtxPos[0], | |
744 | lBestPrimaryVtxPos[1], | |
745 | lMagneticField ) ); | |
746 | ||
747 | lDcaNegToPrimVertexXi = TMath::Abs( nTrackXi ->GetD( lBestPrimaryVtxPos[0], | |
748 | lBestPrimaryVtxPos[1], | |
749 | lMagneticField ) ); | |
750 | ||
751 | ||
752 | // - II.Step 4 : around effective masses (ESD) | |
753 | // ~ change mass hypotheses to cover all the possibilities : Xi-/+, Omega -/+ | |
754 | //------------- | |
755 | ||
756 | lV0quality = 0.; | |
757 | xi->ChangeMassHypothesis(lV0quality , 3312); // Calculate the effective mass of the Xi- candidate. | |
758 | // pdg code 3312 = Xi- | |
759 | if( bachTrackXi->Charge() < 0 ) | |
760 | lInvMassXiMinus = xi->GetEffMassXi(); | |
761 | ||
762 | lV0quality = 0.; | |
763 | xi->ChangeMassHypothesis(lV0quality , -3312); // Calculate the effective mass of the Xi+ candidate. | |
764 | // pdg code -3312 = Xi+ | |
765 | if( bachTrackXi->Charge() > 0 ) | |
766 | lInvMassXiPlus = xi->GetEffMassXi(); | |
767 | ||
768 | lV0quality = 0.; | |
769 | xi->ChangeMassHypothesis(lV0quality , 3334); // Calculate the effective mass of the Xi- candidate. | |
770 | // pdg code 3334 = Omega- | |
771 | if( bachTrackXi->Charge() < 0 ) | |
772 | lInvMassOmegaMinus = xi->GetEffMassXi(); | |
773 | ||
774 | lV0quality = 0.; | |
775 | xi->ChangeMassHypothesis(lV0quality , -3334); // Calculate the effective mass of the Xi+ candidate. | |
776 | // pdg code -3334 = Omega+ | |
777 | if( bachTrackXi->Charge() > 0 ) | |
778 | lInvMassOmegaPlus = xi->GetEffMassXi(); | |
779 | ||
780 | lV0quality = 0.; | |
781 | xi->ChangeMassHypothesis(lV0quality , 3312); // Back to default hyp. | |
782 | ||
783 | ||
784 | // - II.Step 5 : extra info for QA (ESD) | |
785 | // miscellaneous pieces onf info that may help regarding data quality assessment. | |
786 | //------------- | |
787 | ||
788 | xi->GetPxPyPz( lXiMomX, lXiMomY, lXiMomZ ); | |
789 | lXiTransvMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY ); | |
790 | lXiTotMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY + lXiMomZ*lXiMomZ ); | |
791 | ||
792 | xi->GetBPxPyPz( lBachMomX, lBachMomY, lBachMomZ ); | |
793 | lBachTransvMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY ); | |
794 | lBachTotMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY + lBachMomZ*lBachMomZ ); | |
795 | ||
796 | lChargeXi = xi->Charge(); | |
797 | ||
798 | lV0toXiCosineOfPointingAngle = xi->GetV0CosineOfPointingAngle( lPosXi[0], lPosXi[1], lPosXi[2] ); | |
799 | ||
800 | lRapXi = xi->RapXi(); | |
801 | lRapOmega = xi->RapOmega(); | |
802 | lEta = xi->Eta(); | |
803 | lTheta = xi->Theta() *180.0/TMath::Pi(); | |
804 | lPhi = xi->Phi() *180.0/TMath::Pi(); | |
805 | lAlphaXi = xi->AlphaXi(); | |
806 | lPtArmXi = xi->PtArmXi(); | |
807 | ||
808 | ||
809 | }// end of ESD treatment | |
810 | ||
811 | ||
812 | if(fAnalysisType == "AOD"){ | |
813 | ||
814 | // ------------------------------------- | |
815 | // II - Calcultaion Part dedicated to Xi vertices (ESD) | |
816 | ||
817 | const AliAODcascade *xi = lAODevent->GetCascade(iXi); | |
818 | if (!xi) continue; | |
819 | ||
820 | // Just to know which file is currently open : locate the file containing Xi | |
821 | // cout << "Name of the file containing Xi candidate(s) :" << fesdH->GetTree()->GetCurrentFile()->GetName() << endl; | |
822 | ||
823 | ||
824 | // - II.Step 1 : Characteristics of the event : prim. Vtx + magnetic field (AOD) | |
825 | //------------- | |
826 | ||
827 | lTrkgPrimaryVtxPos[0] = -100.0; | |
828 | lTrkgPrimaryVtxPos[1] = -100.0; | |
829 | lTrkgPrimaryVtxPos[2] = -100.0; | |
830 | lTrkgPrimaryVtxRadius3D = -500. ; | |
831 | // We don't have the different prim. vertex at the AOD level -> nothing to do. | |
832 | ||
833 | const AliAODVertex *lPrimaryBestVtx = lAODevent->GetPrimaryVertex(); | |
834 | // get the best primary vertex available for the event | |
835 | // We may keep the one which is the best one available = GetVertex(0) | |
836 | // Pb with pile-up to expect | |
837 | // This one will be used for next calculations (DCA essentially) | |
838 | ||
839 | lPrimaryBestVtx->GetXYZ( lBestPrimaryVtxPos ); | |
840 | lBestPrimaryVtxRadius3D = TMath::Sqrt( lBestPrimaryVtxPos[0] * lBestPrimaryVtxPos[0] + | |
841 | lBestPrimaryVtxPos[1] * lBestPrimaryVtxPos[1] + | |
842 | lBestPrimaryVtxPos[2] * lBestPrimaryVtxPos[2] ); | |
843 | ||
844 | ||
845 | // - II.Step 2 : Assigning the necessary variables for specific AliAODcascade data members (AOD) | |
846 | //------------- | |
847 | ||
848 | lEffMassXi = xi->MassXi(); // default working hypothesis : cascade = Xi- decay | |
849 | lChi2Xi = xi->Chi2Xi(); | |
850 | lDcaXiDaughters = xi->DcaXiDaughters(); | |
851 | lXiCosineOfPointingAngle = xi->CosPointingAngleXi( lBestPrimaryVtxPos[0], | |
852 | lBestPrimaryVtxPos[1], | |
853 | lBestPrimaryVtxPos[2] ); | |
854 | // Take care : | |
855 | // the best available vertex should be used (like in AliCascadeVertexer) | |
856 | ||
857 | lPosXi[0] = xi->DecayVertexXiX(); | |
858 | lPosXi[1] = xi->DecayVertexXiY(); | |
859 | lPosXi[2] = xi->DecayVertexXiZ(); | |
860 | lXiRadius = TMath::Sqrt( lPosXi[0]*lPosXi[0] + lPosXi[1]*lPosXi[1] ); | |
861 | ||
862 | ||
863 | // - II.Step 3 : around the tracks : Bach + V0 (AOD) | |
864 | // ~ Necessary variables for AODcascade data members coming from the AODv0 part (inheritance) | |
865 | //------------- | |
866 | ||
867 | lChargeXi = xi->ChargeXi(); | |
868 | ||
869 | if( lChargeXi < 0) | |
870 | lInvMassLambdaAsCascDghter = xi->MassLambda(); | |
871 | else | |
872 | lInvMassLambdaAsCascDghter = xi->MassAntiLambda(); | |
873 | ||
874 | lDcaV0DaughtersXi = xi->DcaV0Daughters(); | |
875 | lV0Chi2Xi = xi->Chi2V0(); | |
876 | ||
877 | lV0CosineOfPointingAngleXi = xi->CosPointingAngle( lBestPrimaryVtxPos ); | |
878 | lDcaV0ToPrimVertexXi = xi->DcaV0ToPrimVertex(); | |
879 | ||
880 | lDcaBachToPrimVertexXi = xi->DcaBachToPrimVertex(); | |
881 | ||
882 | ||
883 | lPosV0Xi[0] = xi->DecayVertexV0X(); | |
884 | lPosV0Xi[1] = xi->DecayVertexV0Y(); | |
885 | lPosV0Xi[2] = xi->DecayVertexV0Z(); | |
886 | lV0RadiusXi = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0] + lPosV0Xi[1]*lPosV0Xi[1] ); | |
887 | ||
888 | lDcaPosToPrimVertexXi = xi->DcaPosToPrimVertex(); | |
889 | lDcaNegToPrimVertexXi = xi->DcaNegToPrimVertex(); | |
890 | ||
891 | ||
892 | // - II.Step 4 : around effective masses (AOD) | |
893 | // ~ change mass hypotheses to cover all the possibilities : Xi-/+, Omega -/+ | |
894 | //------------- | |
895 | ||
896 | if( lChargeXi < 0 ) lInvMassXiMinus = xi->MassXi(); | |
897 | if( lChargeXi > 0 ) lInvMassXiPlus = xi->MassXi(); | |
898 | if( lChargeXi < 0 ) lInvMassOmegaMinus = xi->MassOmega(); | |
899 | if( lChargeXi > 0 ) lInvMassOmegaPlus = xi->MassOmega(); | |
900 | ||
901 | ||
902 | // - II.Step 5 : extra info for QA (AOD) | |
903 | // miscellaneous pieces onf info that may help regarding data quality assessment. | |
904 | //------------- | |
905 | ||
906 | lXiMomX = xi->MomXiX(); | |
907 | lXiMomY = xi->MomXiY(); | |
908 | lXiMomZ = xi->MomXiZ(); | |
909 | lXiTransvMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY ); | |
910 | lXiTotMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY + lXiMomZ*lXiMomZ ); | |
911 | ||
912 | lBachMomX = xi->MomBachX(); | |
913 | lBachMomY = xi->MomBachY(); | |
914 | lBachMomZ = xi->MomBachZ(); | |
915 | lBachTransvMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY ); | |
916 | lBachTotMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY + lBachMomZ*lBachMomZ ); | |
917 | ||
918 | ||
919 | lV0toXiCosineOfPointingAngle = xi->CosPointingAngle( xi->GetDecayVertexXi() ); | |
920 | ||
921 | lRapXi = xi->RapXi(); | |
922 | lRapOmega = xi->RapOmega(); | |
923 | lEta = xi->Eta(); // Will not work ! need a method Pz(), Py() Px() | |
924 | lTheta = xi->Theta() *180.0/TMath::Pi(); // in AODcascade. | |
925 | lPhi = xi->Phi() *180.0/TMath::Pi(); // Here, we will get eta, theta, phi for the V0 ... | |
926 | lAlphaXi = xi->AlphaXi(); | |
927 | lPtArmXi = xi->PtArmXi(); | |
928 | ||
929 | ||
930 | }// end of AOD treatment | |
931 | ||
932 | ||
933 | // ------------------------------------- | |
934 | // III - Filling the TH1Fs | |
935 | ||
936 | ||
937 | // - III.Step 1 | |
938 | ||
939 | fHistVtxStatus ->Fill( lStatusTrackingPrimVtx ); // 1 if tracking vtx = ok | |
940 | ||
941 | if( lStatusTrackingPrimVtx ){ | |
942 | fHistPosTrkgPrimaryVtxX ->Fill( lTrkgPrimaryVtxPos[0] ); | |
943 | fHistPosTrkgPrimaryVtxY ->Fill( lTrkgPrimaryVtxPos[1] ); | |
944 | fHistPosTrkgPrimaryVtxZ ->Fill( lTrkgPrimaryVtxPos[2] ); | |
945 | fHistTrkgPrimaryVtxRadius->Fill( lTrkgPrimaryVtxRadius3D ); | |
946 | } | |
947 | ||
948 | fHistPosBestPrimaryVtxX ->Fill( lBestPrimaryVtxPos[0] ); | |
949 | fHistPosBestPrimaryVtxY ->Fill( lBestPrimaryVtxPos[1] ); | |
950 | fHistPosBestPrimaryVtxZ ->Fill( lBestPrimaryVtxPos[2] ); | |
951 | fHistBestPrimaryVtxRadius ->Fill( lBestPrimaryVtxRadius3D ); | |
952 | ||
953 | f2dHistTrkgPrimVtxVsBestPrimVtx->Fill( lTrkgPrimaryVtxRadius3D, lBestPrimaryVtxRadius3D ); | |
954 | ||
955 | ||
956 | // - III.Step 2 | |
957 | fHistEffMassXi ->Fill( lEffMassXi ); | |
958 | fHistChi2Xi ->Fill( lChi2Xi ); // Flag CascadeVtxer: Cut Variable a | |
959 | fHistDcaXiDaughters ->Fill( lDcaXiDaughters ); // Flag CascadeVtxer: Cut Variable e | |
960 | fHistDcaBachToPrimVertex ->Fill( lDcaBachToPrimVertexXi ); // Flag CascadeVtxer: Cut Variable d | |
961 | fHistXiCosineOfPointingAngle ->Fill( lXiCosineOfPointingAngle ); // Flag CascadeVtxer: Cut Variable f | |
962 | fHistXiRadius ->Fill( lXiRadius ); // Flag CascadeVtxer: Cut Variable g+h | |
963 | ||
964 | ||
965 | // - III.Step 3 | |
966 | fHistMassLambdaAsCascDghter ->Fill( lInvMassLambdaAsCascDghter ); // Flag CascadeVtxer: Cut Variable c | |
967 | fHistV0Chi2Xi ->Fill( lV0Chi2Xi ); | |
968 | fHistDcaV0DaughtersXi ->Fill( lDcaV0DaughtersXi ); | |
969 | fHistV0CosineOfPointingAngleXi ->Fill( lV0CosineOfPointingAngleXi ); | |
970 | fHistV0RadiusXi ->Fill( lV0RadiusXi ); | |
971 | ||
972 | fHistDcaV0ToPrimVertexXi ->Fill( lDcaV0ToPrimVertexXi ); // Flag CascadeVtxer: Cut Variable b | |
973 | fHistDcaPosToPrimVertexXi ->Fill( lDcaPosToPrimVertexXi ); | |
974 | fHistDcaNegToPrimVertexXi ->Fill( lDcaNegToPrimVertexXi ); | |
975 | ||
976 | ||
977 | // - III.Step 4 | |
978 | if( lChargeXi < 0 ) fHistMassXiMinus ->Fill( lInvMassXiMinus ); | |
979 | if( lChargeXi > 0 ) fHistMassXiPlus ->Fill( lInvMassXiPlus ); | |
980 | if( lChargeXi < 0 ) fHistMassOmegaMinus ->Fill( lInvMassOmegaMinus ); | |
981 | if( lChargeXi > 0 ) fHistMassOmegaPlus ->Fill( lInvMassOmegaPlus ); | |
982 | ||
983 | // if( bachTrackXi->Charge() < 0 ) fHistMassXiMinus ->Fill( lInvMassXiMinus ); | |
984 | // if( bachTrackXi->Charge() > 0 ) fHistMassXiPlus ->Fill( lInvMassXiPlus ); | |
985 | // if( bachTrackXi->Charge() < 0 ) fHistMassOmegaMinus ->Fill( lInvMassOmegaMinus ); | |
986 | // if( bachTrackXi->Charge() > 0 ) fHistMassOmegaPlus ->Fill( lInvMassOmegaPlus ); | |
987 | ||
988 | ||
989 | // - III.Step 5 | |
990 | fHistXiTransvMom ->Fill( lXiTransvMom ); | |
991 | fHistXiTotMom ->Fill( lXiTotMom ); | |
992 | ||
993 | fHistBachTransvMom ->Fill( lBachTransvMom ); | |
994 | fHistBachTotMom ->Fill( lBachTotMom ); | |
995 | ||
996 | fHistChargeXi ->Fill( lChargeXi ); | |
997 | fHistV0toXiCosineOfPointingAngle->Fill( lV0toXiCosineOfPointingAngle ); | |
998 | ||
999 | fHistRapXi ->Fill( lRapXi ); | |
1000 | fHistRapOmega ->Fill( lRapOmega ); | |
1001 | fHistEta ->Fill( lEta ); | |
1002 | fHistTheta ->Fill( lTheta ); | |
1003 | fHistPhi ->Fill( lPhi ); | |
1004 | ||
1005 | f2dHistArmenteros ->Fill( lAlphaXi, lPtArmXi ); | |
1006 | ||
1007 | if( lChargeXi < 0 ) { | |
1008 | f2dHistEffMassLambdaVsEffMassXiMinus->Fill( lInvMassLambdaAsCascDghter, lInvMassXiMinus ); | |
1009 | f2dHistEffMassXiVsEffMassOmegaMinus ->Fill( lInvMassXiMinus, lInvMassOmegaMinus ); | |
1010 | f2dHistXiRadiusVsEffMassXiMinus ->Fill( lXiRadius, lInvMassXiMinus ); | |
1011 | } | |
1012 | else{ | |
1013 | f2dHistEffMassLambdaVsEffMassXiPlus ->Fill( lInvMassLambdaAsCascDghter, lInvMassXiPlus ); | |
1014 | f2dHistEffMassXiVsEffMassOmegaPlus ->Fill( lInvMassXiPlus, lInvMassOmegaPlus ); | |
1015 | f2dHistXiRadiusVsEffMassXiPlus->Fill( lXiRadius, lInvMassXiPlus); | |
1016 | } | |
1017 | ||
1018 | ||
1019 | }// end of the Cascade loop (ESD or AOD) | |
1020 | ||
1021 | ||
1022 | // Post output data. | |
1023 | PostData(1, fListHistCascade); | |
1024 | } | |
1025 | ||
1026 | ||
1027 | ||
1028 | ||
1029 | ||
1030 | ||
1031 | ||
1032 | ||
1033 | ||
1034 | ||
1035 | //________________________________________________________________________ | |
1036 | void AliAnalysisTaskCheckCascade::Terminate(Option_t *) | |
1037 | { | |
1038 | // Draw result to the screen | |
1039 | // Called once at the end of the query | |
1040 | ||
1041 | fHistTrackMultiplicity = dynamic_cast<TH1F*> ( ((TList*)GetOutputData(1))->FindObject("fHistTrackMultiplicity") ); | |
1042 | if (!fHistTrackMultiplicity) { | |
1043 | Printf("ERROR: fHistTrackMultiplicity not available"); | |
1044 | return; | |
1045 | } | |
1046 | ||
1047 | fHistCascadeMultiplicity = dynamic_cast<TH1F*> ( ((TList*)GetOutputData(1))->FindObject("fHistCascadeMultiplicity")); | |
1048 | if (!fHistCascadeMultiplicity) { | |
1049 | Printf("ERROR: fHistCascadeMultiplicity not available"); | |
1050 | return; | |
1051 | } | |
1052 | ||
1053 | TCanvas *c2 = new TCanvas("AliAnalysisTaskCheckCascade","Multiplicity",10,10,510,510); | |
1054 | c2->cd(1)->SetLogy(); | |
1055 | ||
1056 | fHistTrackMultiplicity->SetMarkerStyle(22); | |
1057 | fHistTrackMultiplicity->DrawCopy("E"); | |
1058 | ||
1059 | fHistCascadeMultiplicity->SetMarkerStyle(26); | |
1060 | fHistCascadeMultiplicity->DrawCopy("ESAME"); | |
1061 | ||
1062 | } |