]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG2/SPECTRA/AliAnalysisTaskCheckCascade.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update the define too...
[u/mrichter/AliRoot.git] / PWG2 / SPECTRA / AliAnalysisTaskCheckCascade.cxx
CommitLineData
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
25class TTree;
26class TParticle;
27class TVector3;
28
29//class AliMCEventHandler;
30//class AliMCEvent;
31//class AliStack;
32
33class AliESDVertex;
34class AliAODVertex;
35class AliESDv0;
36class AliAODv0;
37
38#include <iostream>
39
40#include "TList.h"
41#include "TH1F.h"
42#include "TH2F.h"
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
57ClassImp(AliAnalysisTaskCheckCascade)
58
59
60
61//________________________________________________________________________
62AliAnalysisTaskCheckCascade::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//________________________________________________________________________
114AliAnalysisTaskCheckCascade::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//________________________________________________________________________
172void AliAnalysisTaskCheckCascade::UserCreateOutputObjects()
173{
174 // Create histograms
175 // Called once
176
177
178
179 fListHistCascade = new TList();
180
181
182 // - General histos
183
184if(! 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
196if(! 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
210if(! 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
222if(! 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
228if(! 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
233if(! 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
238if(! 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
246if(! 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
251if(! 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
256if(! 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
261if(! fHistBestPrimaryVtxRadius ){
262 fHistBestPrimaryVtxRadius = new TH1F( "fHistBestPrimaryVtxRadius", "Best Prim. vertex radius; r (cm); Events" , 150, 0., 15.0 );
263 fListHistCascade->Add(fHistBestPrimaryVtxRadius);
264}
265
266if(! 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
277if(! 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
282if(! fHistChi2Xi ){
283 fHistChi2Xi = new TH1F("fHistChi2Xi", "Cascade #chi^{2}; #chi^{2}; Number of Cascades", 160, 0, 40);
284 fListHistCascade->Add(fHistChi2Xi);
285}
286
287if(! 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
292if(! 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
297if(! 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
302if(! 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
312if (! 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
317if (! fHistV0Chi2Xi) {
318 fHistV0Chi2Xi = new TH1F("fHistV0Chi2Xi", "V0 #chi^{2}, in cascade; #chi^{2};Counts", 160, 0, 40);
319 fListHistCascade->Add(fHistV0Chi2Xi);
320}
321
322if (! 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
327if (! 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
332if (! 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
337if (! fHistV0RadiusXi) {
338 fHistV0RadiusXi = new TH1F("fHistV0RadiusXi", "V0 decay radius, in cascade; radius (cm); Counts", 200, 0, 20);
339 fListHistCascade->Add(fHistV0RadiusXi);
340}
341
342if (! 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
347if (! 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
357if (! 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
362if (! 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
367if (! 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
372if (! 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
381if(! 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
386if(! 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
392if(! 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
397if(! 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
403if(! fHistChargeXi ){
404 fHistChargeXi = new TH1F( "fHistChargeXi" , "Charge of casc. candidates ; Sign ; Counts", 5, -2.0, 3.0);
405 fListHistCascade->Add(fHistChargeXi);
406}
407
408
409if (! 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
415if(! fHistRapXi ){
416 fHistRapXi = new TH1F( "fHistRapXi" , "Rapidity of Xi candidates ; y ; Counts", 200, -5.0, 5.0);
417 fListHistCascade->Add(fHistRapXi);
418}
419
420if(! fHistRapOmega ){
421 fHistRapOmega = new TH1F( "fHistRapOmega" , "Rapidity of Omega candidates ; y ; Counts", 200, -5.0, 5.0);
422 fListHistCascade->Add(fHistRapOmega);
423}
424
425if(! fHistEta ){
426 fHistEta = new TH1F( "fHistEta" , "Pseudo-rap. of casc. candidates ; #eta ; Counts", 120, -3.0, 3.0);
427 fListHistCascade->Add(fHistEta);
428}
429
430if(! fHistTheta ){
431 fHistTheta = new TH1F( "fHistTheta" , "#theta of casc. candidates ; #theta (deg) ; Counts", 180, 0., 180.0);
432 fListHistCascade->Add(fHistTheta);
433}
434
435if(! fHistPhi ){
436 fHistPhi = new TH1F( "fHistPhi" , "#phi of casc. candidates ; #phi (deg) ; Counts", 360, 0., 360.);
437 fListHistCascade->Add(fHistPhi);
438}
439
440
441if(! 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
446if(! 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
451if(! 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
456if(! 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
461if(! 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
466if(! 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
471if(! 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//________________________________________________________________________
487void 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//________________________________________________________________________
1036void 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}