1 /**************************************************************************
2 * Author: Boris Hippolyte. *
3 * Contributors are mentioned in the code where appropriate. *
5 * Permission to use, copy, modify and distribute this software and its *
6 * documentation strictly for non-commercial purposes is hereby granted *
7 * without fee, provided that the above copyright notice appears in all *
8 * copies and that both the copyright notice and this permission notice *
9 * appear in the supporting documentation. The authors make no claims *
10 * about the suitability of this software for any purpose. It is *
11 * provided "as is" without express or implied warranty. *
12 **************************************************************************/
14 //-----------------------------------------------------------------
15 // AliAnalysisTaskCheckV0 class
16 // This task is for QAing the V0s from ESD/AOD
17 // Origin: B.H. Nov2007, hippolyt@in2p3.fr
18 //-----------------------------------------------------------------
27 #include "AliAnalysisTaskSE.h"
28 #include "AliAnalysisManager.h"
29 #include "AliInputEventHandler.h"
31 #include "AliESDEvent.h"
32 #include "AliESDVertex.h"
33 #include "AliAODEvent.h"
37 #include "AliAnalysisTaskCheckV0.h"
39 ClassImp(AliAnalysisTaskCheckV0)
41 //________________________________________________________________________
42 AliAnalysisTaskCheckV0::AliAnalysisTaskCheckV0()
43 : AliAnalysisTaskSE(), fAnalysisType("ESD"), fCollidingSystems(0), fUsePhysicsSelection(0),
44 fMaxPrimaryVtxPosZ(100.), fMinV0Pt(0.), fMaxV0Pt(100.), fMaxV0Rapidity(1.), fMinDaughterTpcClusters(80),
46 fHistPrimaryVertexPosX(0), fHistPrimaryVertexPosY(0), fHistPrimaryVertexPosZ(0),
47 fHistKeptPrimaryVertexPosX(0), fHistKeptPrimaryVertexPosY(0), fHistKeptPrimaryVertexPosZ(0),
48 fHistTrackMultiplicity(0), fHistV0Multiplicity(0), fHistV0OnFlyStatus(0),
49 fHistV0MultiplicityOff(0),
51 fHistDcaV0DaughtersOff(0), fHistV0CosineOfPointingAngleOff(0),
52 fHistV0RadiusOff(0),fHistDcaV0ToPrimVertexOff(0),
53 fHistDcaPosToPrimVertexOff(0),fHistDcaNegToPrimVertexOff(0),
54 fHistMassK0sOff(0),fHistMassLambdaOff(0),fHistMassAntiLambdaOff(0),
55 fHistMassK0sOffVsPt(0),fHistMassLambdaOffVsPt(0),fHistMassAntiLambdaOffVsPt(0),
56 fHistArmenterosPodolanskiOff(0),
57 fHistV0MultiplicityOn(0),
59 fHistDcaV0DaughtersOn(0), fHistV0CosineOfPointingAngleOn(0),
60 fHistV0RadiusOn(0),fHistDcaV0ToPrimVertexOn(0),
61 fHistDcaPosToPrimVertexOn(0),fHistDcaNegToPrimVertexOn(0),
62 fHistMassK0sOn(0),fHistMassLambdaOn(0),fHistMassAntiLambdaOn(0),
63 fHistMassK0sOnVsPt(0),fHistMassLambdaOnVsPt(0),fHistMassAntiLambdaOnVsPt(0),
64 fHistArmenterosPodolanskiOn(0)
68 //________________________________________________________________________
69 AliAnalysisTaskCheckV0::AliAnalysisTaskCheckV0(const char *name)
70 : AliAnalysisTaskSE(name), fAnalysisType("ESD"), fCollidingSystems(0), fUsePhysicsSelection(0),
71 fMaxPrimaryVtxPosZ(100.), fMinV0Pt(0.), fMaxV0Pt(100.), fMaxV0Rapidity(1.), fMinDaughterTpcClusters(80),
73 fHistPrimaryVertexPosX(0), fHistPrimaryVertexPosY(0), fHistPrimaryVertexPosZ(0),
74 fHistKeptPrimaryVertexPosX(0), fHistKeptPrimaryVertexPosY(0), fHistKeptPrimaryVertexPosZ(0),
75 fHistTrackMultiplicity(0), fHistV0Multiplicity(0), fHistV0OnFlyStatus(0),
76 fHistV0MultiplicityOff(0),
78 fHistDcaV0DaughtersOff(0), fHistV0CosineOfPointingAngleOff(0),
79 fHistV0RadiusOff(0),fHistDcaV0ToPrimVertexOff(0),
80 fHistDcaPosToPrimVertexOff(0),fHistDcaNegToPrimVertexOff(0),
81 fHistMassK0sOff(0),fHistMassLambdaOff(0),fHistMassAntiLambdaOff(0),
82 fHistMassK0sOffVsPt(0),fHistMassLambdaOffVsPt(0),fHistMassAntiLambdaOffVsPt(0),
83 fHistArmenterosPodolanskiOff(0),
84 fHistV0MultiplicityOn(0),
86 fHistDcaV0DaughtersOn(0), fHistV0CosineOfPointingAngleOn(0),
87 fHistV0RadiusOn(0),fHistDcaV0ToPrimVertexOn(0),
88 fHistDcaPosToPrimVertexOn(0),fHistDcaNegToPrimVertexOn(0),
89 fHistMassK0sOn(0),fHistMassLambdaOn(0),fHistMassAntiLambdaOn(0),
90 fHistMassK0sOnVsPt(0),fHistMassLambdaOnVsPt(0),fHistMassAntiLambdaOnVsPt(0),
91 fHistArmenterosPodolanskiOn(0)
94 // Define output slots only here
95 // Output slot #1 writes into a TList container
96 DefineOutput(1, TList::Class());
98 //________________________________________________________________________
99 AliAnalysisTaskCheckV0::~AliAnalysisTaskCheckV0(){
101 if (fListHist) { delete fListHist; fListHist = 0x0; }
103 //________________________________________________________________________
104 void AliAnalysisTaskCheckV0::UserCreateOutputObjects()
109 // Distinguish Track and V0 Multiplicity !
111 fListHist = new TList();
112 fListHist->SetOwner();
114 if (!fHistPrimaryVertexPosX) {
115 fHistPrimaryVertexPosX = new TH1F("fHistPrimaryVertexPosX", "Primary vertex position in x;Position in x (cm);Events;",100,-1,1);
116 fListHist->Add(fHistPrimaryVertexPosX);
118 if (!fHistPrimaryVertexPosY) {
119 fHistPrimaryVertexPosY = new TH1F("fHistPrimaryVertexPosY", "Primary vertex position in y;Position in y (cm);Events;",100,-1,1);
120 fListHist->Add(fHistPrimaryVertexPosY);
122 if (!fHistPrimaryVertexPosZ) {
123 fHistPrimaryVertexPosZ = new TH1F("fHistPrimaryVertexPosZ", "Primary vertex position in z;Position in z (cm);Events;",100,-1,1);
124 fListHist->Add(fHistPrimaryVertexPosZ);
126 if (!fHistKeptPrimaryVertexPosX) {
127 fHistKeptPrimaryVertexPosX = new TH1F("fHistKeptPrimaryVertexPosX", "Kept Primary vertex position in x;Position in x (cm);Events;",100,-1,1);
128 fListHist->Add(fHistKeptPrimaryVertexPosX);
130 if (!fHistKeptPrimaryVertexPosY) {
131 fHistKeptPrimaryVertexPosY = new TH1F("fHistKeptPrimaryVertexPosY", "Kept Primary vertex position in y;Position in y (cm);Events;",100,-1,1);
132 fListHist->Add(fHistKeptPrimaryVertexPosY);
134 if (!fHistKeptPrimaryVertexPosZ) {
135 fHistKeptPrimaryVertexPosZ = new TH1F("fHistKeptPrimaryVertexPosZ", "Kept Primary vertex position in z;Position in z (cm);Events;",100,-1,1);
136 fListHist->Add(fHistKeptPrimaryVertexPosZ);
139 if (!fHistTrackMultiplicity) {
140 if (fCollidingSystems)
141 fHistTrackMultiplicity = new TH1F("fHistTrackMultiplicity", "Multiplicity distribution;Number of tracks;Events", 200, 0, 40000);
143 fHistTrackMultiplicity = new TH1F("fHistTrackMultiplicity", "Multiplicity distribution;Number of tracks;Events", 250, 0, 250);
144 fListHist->Add(fHistTrackMultiplicity);
146 if (!fHistV0Multiplicity) {
147 if (fCollidingSystems)
148 fHistV0Multiplicity = new TH1F("fHistV0Multiplicity", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000);
150 fHistV0Multiplicity = new TH1F("fHistV0Multiplicity", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50);
151 fListHist->Add(fHistV0Multiplicity);
153 if (!fHistV0OnFlyStatus) {
154 fHistV0OnFlyStatus = new TH1F("fHistV0OnFlyStatus", "V0 On fly status;status;Number of V0s", 3, 0, 3);
155 fListHist->Add(fHistV0OnFlyStatus);
158 // V0 offline distributions
159 if (!fHistV0MultiplicityOff) {
160 if (fCollidingSystems)
161 fHistV0MultiplicityOff = new TH1F("fHistV0MultiplicityOff", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000);
163 fHistV0MultiplicityOff = new TH1F("fHistV0MultiplicityOff", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50);
164 fListHist->Add(fHistV0MultiplicityOff);
166 if (!fHistV0Chi2Off) {
167 fHistV0Chi2Off = new TH1F("fHistV0Chi2Off", "V0 chi2;chi2;Number of V0s", 33, 0, 33);
168 fListHist->Add(fHistV0Chi2Off);
170 if (!fHistDcaV0DaughtersOff) {
171 fHistDcaV0DaughtersOff = new TH1F("fHistDcaV0DaughtersOff", "DCA between V0 daughters;DCA (cm);Number of V0s", 300, 0, 3);
172 fListHist->Add(fHistDcaV0DaughtersOff);
174 if (!fHistV0CosineOfPointingAngleOff) {
175 fHistV0CosineOfPointingAngleOff = new TH1F("fHistV0CosineOfPointingAngleOff", "V0 Cosine of Pointing Angle;Number of V0s", 200, 0, 1);
176 fListHist->Add(fHistV0CosineOfPointingAngleOff);
178 if (!fHistV0RadiusOff) {
179 fHistV0RadiusOff = new TH1F("fHistV0RadiusOff", "V0 decay radius;Radius (cm);Number of V0s", 33, 0, 33);
180 fListHist->Add(fHistV0RadiusOff);
182 if (!fHistDcaV0ToPrimVertexOff) {
183 fHistDcaV0ToPrimVertexOff = new TH1F("fHistDcaV0ToPrimVertexOff", "DCA of V0 to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
184 fListHist->Add(fHistDcaV0ToPrimVertexOff);
186 if (!fHistDcaPosToPrimVertexOff) {
187 fHistDcaPosToPrimVertexOff = new TH1F("fHistDcaPosToPrimVertexOff", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
188 fListHist->Add(fHistDcaPosToPrimVertexOff);
190 if (!fHistDcaNegToPrimVertexOff) {
191 fHistDcaNegToPrimVertexOff = new TH1F("fHistDcaNegToPrimVertexOff", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
192 fListHist->Add(fHistDcaNegToPrimVertexOff);
195 if (!fHistMassK0sOff) {
196 fHistMassK0sOff = new TH1F("fHistMassK0sOff","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts",100,0.4,0.6);
197 fListHist->Add(fHistMassK0sOff);
199 if (!fHistMassLambdaOff) {
200 fHistMassLambdaOff = new TH1F("fHistMassLambdaOff","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts",75,1.05,1.2);
201 fListHist->Add(fHistMassLambdaOff);
203 if (!fHistMassAntiLambdaOff) {
204 fHistMassAntiLambdaOff = new TH1F("fHistMassAntiLambdaOff","#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts",75,1.05,1.2);
205 fListHist->Add(fHistMassAntiLambdaOff);
207 if (!fHistMassK0sOffVsPt) {
208 fHistMassK0sOffVsPt = new TH2F("fHistMassK0sOffVsPt","K^{0} candidates;p_{T} (GeV/c);M(#pi^{+}#pi^{-}) (GeV/c^{2})",200,0,10,100,0.4,0.6);
209 fListHist->Add(fHistMassK0sOffVsPt);
211 if (!fHistMassLambdaOffVsPt) {
212 fHistMassLambdaOffVsPt = new TH2F("fHistMassLambdaOffVsPt","#Lambda^{0} candidates;p_{T} (GeV/c);M(p#pi^{-}) (GeV/c^{2})",200,0,10,75,1.05,1.2);
213 fListHist->Add(fHistMassLambdaOffVsPt);
215 if (!fHistMassAntiLambdaOffVsPt) {
216 fHistMassAntiLambdaOffVsPt = new TH2F("fHistMassAntiLambdaOffVsPt","#bar{#Lambda}^{0} candidates;p_{T} (GeV/c);M(#bar{p}#pi^{+}) (GeV/c^{2})",200,0,10,75,1.05,1.2);
217 fListHist->Add(fHistMassAntiLambdaOffVsPt);
219 if (!fHistArmenterosPodolanskiOff) {
220 fHistArmenterosPodolanskiOff = new TH2F("fHistArmenterosPodolanskiOff","Armenteros-Podolanski Offline phase space;#alpha;p_{t} arm",200,-1.0,1.0,150,0,0.3);
221 fListHist->Add(fHistArmenterosPodolanskiOff);
224 // V0 on-the-fly distributions
225 if (!fHistV0MultiplicityOn) {
226 if (fCollidingSystems)
227 fHistV0MultiplicityOn = new TH1F("fHistV0MultiplicityOn", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000);
229 fHistV0MultiplicityOn = new TH1F("fHistV0MultiplicityOn", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50);
230 fListHist->Add(fHistV0MultiplicityOn);
232 if (!fHistV0Chi2On) {
233 fHistV0Chi2On = new TH1F("fHistV0Chi2On", "V0 chi2;chi2;Number of V0s", 33, 0, 33);
234 fListHist->Add(fHistV0Chi2On);
236 if (!fHistDcaV0DaughtersOn) {
237 fHistDcaV0DaughtersOn = new TH1F("fHistDcaV0DaughtersOn", "DCA between V0 daughters;DCA (cm);Number of V0s", 300, 0, 3);
238 fListHist->Add(fHistDcaV0DaughtersOn);
240 if (!fHistV0CosineOfPointingAngleOn) {
241 fHistV0CosineOfPointingAngleOn = new TH1F("fHistV0CosineOfPointingAngleOn", "V0 Cosine of Pointing Angle;Number of V0s", 200, 0, 1);
242 fListHist->Add(fHistV0CosineOfPointingAngleOn);
244 if (!fHistV0RadiusOn) {
245 fHistV0RadiusOn = new TH1F("fHistV0RadiusOn", "V0 decay radius;Radius (cm);Number of V0s", 33, 0, 33);
246 fListHist->Add(fHistV0RadiusOn);
248 if (!fHistDcaV0ToPrimVertexOn) {
249 fHistDcaV0ToPrimVertexOn = new TH1F("fHistDcaV0ToPrimVertexOn", "DCA of V0 to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
250 fListHist->Add(fHistDcaV0ToPrimVertexOn);
252 if (!fHistDcaPosToPrimVertexOn) {
253 fHistDcaPosToPrimVertexOn = new TH1F("fHistDcaPosToPrimVertexOn", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
254 fListHist->Add(fHistDcaPosToPrimVertexOn);
256 if (!fHistDcaNegToPrimVertexOn) {
257 fHistDcaNegToPrimVertexOn = new TH1F("fHistDcaNegToPrimVertexOn", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
258 fListHist->Add(fHistDcaNegToPrimVertexOn);
261 if (!fHistMassK0sOn) {
262 fHistMassK0sOn = new TH1F("fHistMassK0sOn","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts",100,0.4,0.6);
263 fListHist->Add(fHistMassK0sOn);
265 if (!fHistMassLambdaOn) {
266 fHistMassLambdaOn = new TH1F("fHistMassLambdaOn","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts",75,1.05,1.2);
267 fListHist->Add(fHistMassLambdaOn);
269 if (!fHistMassAntiLambdaOn) {
270 fHistMassAntiLambdaOn = new TH1F("fHistMassAntiLambdaOn","#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts",75,1.05,1.2);
271 fListHist->Add(fHistMassAntiLambdaOn);
273 if (!fHistMassK0sOnVsPt) {
274 fHistMassK0sOnVsPt = new TH2F("fHistMassK0sOnVsPt","K^{0} candidates;p_{T} (GeV/c);M(#pi^{+}#pi^{-}) (GeV/c^{2})",200,0,10,100,0.4,0.6);
275 fListHist->Add(fHistMassK0sOnVsPt);
277 if (!fHistMassLambdaOnVsPt) {
278 fHistMassLambdaOnVsPt = new TH2F("fHistMassLambdaOnVsPt","#Lambda^{0} candidates;p_{T} (GeV/c);M(p#pi^{-}) (GeV/c^{2})",200,0,10,75,1.05,1.2);
279 fListHist->Add(fHistMassLambdaOnVsPt);
281 if (!fHistMassAntiLambdaOnVsPt) {
282 fHistMassAntiLambdaOnVsPt = new TH2F("fHistMassAntiLambdaOnVsPt","#bar{#Lambda}^{0} candidates;p_{T} (GeV/c);M(#bar{p}#pi^{+}) (GeV/c^{2})",200,0,10,75,1.05,1.2);
283 fListHist->Add(fHistMassAntiLambdaOnVsPt);
285 if (!fHistArmenterosPodolanskiOn) {
286 fHistArmenterosPodolanskiOn = new TH2F("fHistArmenterosPodolanskiOn","Armenteros-Podolanski Onthefly phase space;#alpha;p_{t} arm",200,-1.0,1.0,150,0,0.3);
287 fListHist->Add(fHistArmenterosPodolanskiOn);
290 PostData(1, fListHist);
293 //________________________________________________________________________
294 void AliAnalysisTaskCheckV0::UserExec(Option_t *)
297 // Called for each event
298 AliVEvent* lEvent = InputEvent();
300 Printf("ERROR: Event not available");
304 Bool_t isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
305 if ((fUsePhysicsSelection)&&(!isSelected)) return;
307 fHistTrackMultiplicity->Fill(lEvent->GetNumberOfTracks());
309 Double_t tPrimaryVtxPosition[3];
311 nv0s = lEvent->GetNumberOfV0s();
312 // Printf("CheckV0 analysis task: There are %d v0s in this event",nv0s);
314 Int_t lOnFlyStatus = 0, nv0sOn = 0, nv0sOff = 0;
315 Double_t lChi2V0 = 0;
316 Double_t lDcaV0Daughters = 0, lDcaV0ToPrimVertex = 0;
317 Double_t lDcaPosToPrimVertex = 0, lDcaNegToPrimVertex = 0;
318 Double_t lV0CosineOfPointingAngle = 0;
319 Double_t lV0Radius = 0, lPt = 0;
320 Double_t lRapK0Short = 0, lRapLambda = 0;
321 Double_t lInvMassK0s = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0;
322 Double_t lAlphaV0 = 0, lPtArmV0 = 0;
324 const AliVVertex *primaryVtx = lEvent->GetPrimaryVertex();
325 tPrimaryVtxPosition[0] = primaryVtx->GetX();
326 tPrimaryVtxPosition[1] = primaryVtx->GetY();
327 tPrimaryVtxPosition[2] = primaryVtx->GetZ();
328 fHistPrimaryVertexPosX->Fill(tPrimaryVtxPosition[0]);
329 fHistPrimaryVertexPosY->Fill(tPrimaryVtxPosition[1]);
330 fHistPrimaryVertexPosZ->Fill(tPrimaryVtxPosition[2]);
332 if (TMath::Abs(tPrimaryVtxPosition[2])<fMaxPrimaryVtxPosZ){// event selections
334 fHistKeptPrimaryVertexPosX->Fill(tPrimaryVtxPosition[0]);
335 fHistKeptPrimaryVertexPosY->Fill(tPrimaryVtxPosition[1]);
336 fHistKeptPrimaryVertexPosZ->Fill(tPrimaryVtxPosition[2]);
338 if(fAnalysisType == "ESD") {
340 Double_t lMagneticField = ((AliESDEvent*)lEvent)->GetMagneticField();
342 for (Int_t iV0 = 0; iV0 < nv0s; iV0++)
343 {// This is the begining of the V0 loop
344 AliESDv0 *v0 = ((AliESDEvent*)lEvent)->GetV0(iV0);
347 Double_t tDecayVertexV0[3]; v0->GetXYZ(tDecayVertexV0[0],tDecayVertexV0[1],tDecayVertexV0[2]);
349 lV0Radius = TMath::Sqrt(tDecayVertexV0[0]*tDecayVertexV0[0]+tDecayVertexV0[1]*tDecayVertexV0[1]);
351 lRapK0Short = v0->RapK0Short();
352 lRapLambda = v0->RapLambda();
353 if ((lPt<fMinV0Pt)||(fMaxV0Pt<lPt)) continue;
355 UInt_t lKeyPos = (UInt_t)TMath::Abs(v0->GetPindex());
356 UInt_t lKeyNeg = (UInt_t)TMath::Abs(v0->GetNindex());
358 Double_t lMomPos[3]; v0->GetPPxPyPz(lMomPos[0],lMomPos[1],lMomPos[2]);
359 Double_t lMomNeg[3]; v0->GetNPxPyPz(lMomNeg[0],lMomNeg[1],lMomNeg[2]);
361 AliESDtrack *pTrack=((AliESDEvent*)lEvent)->GetTrack(lKeyPos);
362 AliESDtrack *nTrack=((AliESDEvent*)lEvent)->GetTrack(lKeyNeg);
363 if (!pTrack || !nTrack) {
364 Printf("ERROR: Could not retreive one of the daughter track");
368 // Filter like-sign V0 (next: add counter and distribution)
369 if ( pTrack->GetSign() == nTrack->GetSign()){
373 // WARNING: the following selections cannot be done for AOD yet...
375 // Tracks quality cuts
376 if ( ( (pTrack->GetTPCNcls()) < fMinDaughterTpcClusters ) || ( (nTrack->GetTPCNcls()) < fMinDaughterTpcClusters ) ) continue;
378 // TPC refit condition (done during reconstruction for Offline but not for On-the-fly)
379 if( !(pTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue;
380 if( !(nTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue;
383 lDcaPosToPrimVertex = TMath::Abs(pTrack->GetD(tPrimaryVtxPosition[0],
384 tPrimaryVtxPosition[1],
387 lDcaNegToPrimVertex = TMath::Abs(nTrack->GetD(tPrimaryVtxPosition[0],
388 tPrimaryVtxPosition[1],
391 lOnFlyStatus = v0->GetOnFlyStatus();
392 lChi2V0 = v0->GetChi2V0();
393 lDcaV0Daughters = v0->GetDcaV0Daughters();
394 lDcaV0ToPrimVertex = v0->GetD(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]);
395 lV0CosineOfPointingAngle = v0->GetV0CosineOfPointingAngle(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]);
397 // Getting invariant mass infos directly from ESD
398 v0->ChangeMassHypothesis(310);
399 lInvMassK0s = v0->GetEffMass();
400 v0->ChangeMassHypothesis(3122);
401 lInvMassLambda = v0->GetEffMass();
402 v0->ChangeMassHypothesis(-3122);
403 lInvMassAntiLambda = v0->GetEffMass();
404 lAlphaV0 = v0->AlphaV0();
405 lPtArmV0 = v0->PtArmV0();
407 fHistV0OnFlyStatus->Fill(lOnFlyStatus);
410 fHistV0Chi2Off->Fill(lChi2V0);
411 fHistDcaV0ToPrimVertexOff->Fill(lDcaV0ToPrimVertex);
412 fHistDcaV0DaughtersOff->Fill(lDcaV0Daughters);
413 fHistV0CosineOfPointingAngleOff->Fill(lV0CosineOfPointingAngle);
415 fHistV0RadiusOff->Fill(lV0Radius);
416 fHistDcaPosToPrimVertexOff->Fill(lDcaPosToPrimVertex);
417 fHistDcaNegToPrimVertexOff->Fill(lDcaNegToPrimVertex);
419 // Filling invariant mass histos for all candidates
420 fHistMassK0sOff->Fill(lInvMassK0s);
421 fHistMassLambdaOff->Fill(lInvMassLambda);
422 fHistMassAntiLambdaOff->Fill(lInvMassAntiLambda);
423 if (TMath::Abs(lRapK0Short)<fMaxV0Rapidity)
424 fHistMassK0sOffVsPt->Fill(lPt,lInvMassK0s);
425 if (TMath::Abs(lRapLambda)<fMaxV0Rapidity){
426 fHistMassLambdaOffVsPt->Fill(lPt,lInvMassLambda);
427 fHistMassAntiLambdaOffVsPt->Fill(lPt,lInvMassAntiLambda);
429 fHistArmenterosPodolanskiOff->Fill(lAlphaV0,lPtArmV0);
433 fHistV0Chi2On->Fill(lChi2V0);
434 fHistDcaV0ToPrimVertexOn->Fill(lDcaV0ToPrimVertex);
435 fHistDcaV0DaughtersOn->Fill(lDcaV0Daughters);
436 fHistV0CosineOfPointingAngleOn->Fill(lV0CosineOfPointingAngle);
438 fHistV0RadiusOn->Fill(lV0Radius);
439 fHistDcaPosToPrimVertexOn->Fill(lDcaPosToPrimVertex);
440 fHistDcaNegToPrimVertexOn->Fill(lDcaNegToPrimVertex);
442 // Filling invariant mass histos for all candidates
443 fHistMassK0sOn->Fill(lInvMassK0s);
444 fHistMassLambdaOn->Fill(lInvMassLambda);
445 fHistMassAntiLambdaOn->Fill(lInvMassAntiLambda);
446 if (TMath::Abs(lRapK0Short)<fMaxV0Rapidity)
447 fHistMassK0sOnVsPt->Fill(lPt,lInvMassK0s);
448 if (TMath::Abs(lRapLambda)<fMaxV0Rapidity){
449 fHistMassLambdaOnVsPt->Fill(lPt,lInvMassLambda);
450 fHistMassAntiLambdaOnVsPt->Fill(lPt,lInvMassAntiLambda);
452 fHistArmenterosPodolanskiOn->Fill(lAlphaV0,lPtArmV0);
454 }// This is the end of the V0 loop
455 } // end of "ESD" analysis
457 else if(fAnalysisType == "AOD") {
459 for (Int_t iV0 = 0; iV0 < nv0s; iV0++)
460 {// This is the begining of the V0 loop
461 AliAODv0 *v0 = ((AliAODEvent*)lEvent)->GetV0(iV0);
464 lV0Radius = v0->RadiusV0();
466 lRapK0Short = v0->RapK0Short();
467 lRapLambda = v0->RapLambda();
468 if ((lPt<fMinV0Pt)||(fMaxV0Pt<lPt)) continue;
469 lDcaPosToPrimVertex = v0->DcaPosToPrimVertex();
470 lDcaNegToPrimVertex = v0->DcaNegToPrimVertex();
472 // propose getOnFlyStatus() = -1 for like-sign
474 lOnFlyStatus = v0->GetOnFlyStatus();
475 lChi2V0 = v0->Chi2V0();
476 lDcaV0Daughters = v0->DcaV0Daughters();
477 lDcaV0ToPrimVertex = v0->DcaV0ToPrimVertex();
478 lV0CosineOfPointingAngle = v0->CosPointingAngle(tPrimaryVtxPosition);
480 lInvMassK0s = v0->MassK0Short();
481 lInvMassLambda = v0->MassLambda();
482 lInvMassAntiLambda = v0->MassAntiLambda();
483 lAlphaV0 = v0->AlphaV0();
484 lPtArmV0 = v0->PtArmV0();
486 fHistV0OnFlyStatus->Fill(lOnFlyStatus);
489 fHistV0Chi2Off->Fill(lChi2V0);
490 fHistDcaV0ToPrimVertexOff->Fill(lDcaV0ToPrimVertex);
491 fHistDcaV0DaughtersOff->Fill(lDcaV0Daughters);
492 fHistV0CosineOfPointingAngleOff->Fill(lV0CosineOfPointingAngle);
494 fHistV0RadiusOff->Fill(lV0Radius);
495 fHistDcaPosToPrimVertexOff->Fill(lDcaPosToPrimVertex);
496 fHistDcaNegToPrimVertexOff->Fill(lDcaNegToPrimVertex);
498 // Filling invariant mass histos for all candidates
499 fHistMassK0sOff->Fill(lInvMassK0s);
500 fHistMassLambdaOff->Fill(lInvMassLambda);
501 fHistMassAntiLambdaOff->Fill(lInvMassAntiLambda);
502 if (TMath::Abs(lRapK0Short)<fMaxV0Rapidity)
503 fHistMassK0sOffVsPt->Fill(lPt,lInvMassK0s);
504 if (TMath::Abs(lRapLambda)<fMaxV0Rapidity){
505 fHistMassLambdaOffVsPt->Fill(lPt,lInvMassLambda);
506 fHistMassAntiLambdaOffVsPt->Fill(lPt,lInvMassAntiLambda);
508 fHistArmenterosPodolanskiOff->Fill(lAlphaV0,lPtArmV0);
512 fHistV0Chi2On->Fill(lChi2V0);
513 fHistDcaV0ToPrimVertexOn->Fill(lDcaV0ToPrimVertex);
514 fHistDcaV0DaughtersOn->Fill(lDcaV0Daughters);
515 fHistV0CosineOfPointingAngleOn->Fill(lV0CosineOfPointingAngle);
517 fHistV0RadiusOn->Fill(lV0Radius);
518 fHistDcaPosToPrimVertexOn->Fill(lDcaPosToPrimVertex);
519 fHistDcaNegToPrimVertexOn->Fill(lDcaNegToPrimVertex);
521 // Filling invariant mass histos for all candidates
522 fHistMassK0sOn->Fill(lInvMassK0s);
523 fHistMassLambdaOn->Fill(lInvMassLambda);
524 fHistMassAntiLambdaOn->Fill(lInvMassAntiLambda);
525 if (TMath::Abs(lRapK0Short)<fMaxV0Rapidity)
526 fHistMassK0sOnVsPt->Fill(lPt,lInvMassK0s);
527 if (TMath::Abs(lRapLambda)<fMaxV0Rapidity){
528 fHistMassLambdaOnVsPt->Fill(lPt,lInvMassLambda);
529 fHistMassAntiLambdaOnVsPt->Fill(lPt,lInvMassAntiLambda);
531 fHistArmenterosPodolanskiOn->Fill(lAlphaV0,lPtArmV0);
533 }// This is the end of the V0 loop
534 } // end of "AOD" analysis
536 fHistV0Multiplicity->Fill(nv0s);
537 fHistV0MultiplicityOff->Fill(nv0sOff);
538 fHistV0MultiplicityOn->Fill(nv0sOn);
540 }// end of event selection
543 PostData(1, fListHist);
546 //________________________________________________________________________
547 void AliAnalysisTaskCheckV0::Terminate(Option_t *)
549 // Draw result to the screen
550 // Called once at the end of the query
552 TList *cRetrievedList = 0x0;
553 cRetrievedList = (TList*)GetOutputData(1);
556 AliWarning("ERROR - AliAnalysisTaskCheckV0: output data container list not available\n"); return;
559 // Implement a decent style
560 TStyle *myStyle = new TStyle("myStyle","my style");
562 myStyle->SetCanvasColor(10);
563 myStyle->SetStatColor(10);
564 myStyle->SetPadColor(10);
565 myStyle->SetDrawBorder(0);
566 myStyle->SetCanvasBorderMode(0);
567 myStyle->SetPadBorderMode(0);
568 myStyle->SetTextFont(font);
569 myStyle->SetStatFont(font);
570 myStyle->SetLabelFont(font,"xyz");
571 myStyle->SetTitleFont(font);
572 myStyle->SetPalette(1,0);
575 fHistTrackMultiplicity = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistTrackMultiplicity"));
576 if (!fHistTrackMultiplicity) {
577 Printf("ERROR: fHistTrackMultiplicity not available");
580 fHistV0Multiplicity = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistV0Multiplicity"));
581 if (!fHistV0Multiplicity) {
582 Printf("ERROR: fHistV0Multiplicity not available");
585 fHistV0MultiplicityOff = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistV0MultiplicityOff"));
586 if (!fHistV0MultiplicityOff) {
587 Printf("ERROR: fHistV0MultiplicityOff not available");
590 fHistV0MultiplicityOn = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistV0MultiplicityOn"));
591 if (!fHistV0MultiplicityOn) {
592 Printf("ERROR: fHistV0MultiplicityOn not available");
596 TCanvas *canCheckV0 = new TCanvas("AliAnalysisTaskCheckV0","Check V0",10,10,510,700);
597 canCheckV0->Divide(2,3);
598 if (fHistTrackMultiplicity->GetMaximum() > 0.) canCheckV0->cd(1)->SetLogy();
599 fHistTrackMultiplicity->SetMarkerStyle(26);
600 fHistTrackMultiplicity->DrawCopy("E");
601 fHistV0Multiplicity->SetMarkerStyle(25);
602 fHistV0Multiplicity->DrawCopy("ESAME");
603 fHistV0MultiplicityOff->SetMarkerStyle(24);
604 fHistV0MultiplicityOff->DrawCopy("ESAME");
605 fHistV0MultiplicityOn->SetMarkerStyle(20);
606 fHistV0MultiplicityOn->DrawCopy("ESAME");
608 TLegend *legendMultiplicity = new TLegend(0.5,0.5,0.75,0.75);
609 legendMultiplicity->AddEntry(fHistTrackMultiplicity,"tracks");
610 legendMultiplicity->AddEntry(fHistV0Multiplicity,"all V^{0}");
611 legendMultiplicity->AddEntry(fHistV0MultiplicityOff,"offline V^{0}");
612 legendMultiplicity->AddEntry(fHistV0MultiplicityOn,"onthefly V^{0}");
613 legendMultiplicity->Draw();
615 fHistMassK0sOff = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistMassK0sOff"));
616 if (!fHistMassK0sOff) {
617 Printf("ERROR: fHistMassK0sOff not available");
620 fHistMassK0sOn = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistMassK0sOn"));
621 if (!fHistMassK0sOn) {
622 Printf("ERROR: fHistMassK0sOn not available");
625 fHistMassLambdaOff = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistMassLambdaOff"));
626 if (!fHistMassLambdaOff) {
627 Printf("ERROR: fHistMassLambdaOff not available");
630 fHistMassLambdaOn = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistMassLambdaOn"));
631 if (!fHistMassLambdaOn) {
632 Printf("ERROR: fHistMassLambdaOn not available");
635 fHistMassAntiLambdaOff = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistMassAntiLambdaOff"));
636 if (!fHistMassAntiLambdaOff) {
637 Printf("ERROR: fHistMassAntiLambdaOff not available");
640 fHistMassAntiLambdaOn = dynamic_cast<TH1F*> (cRetrievedList->FindObject("fHistMassAntiLambdaOn"));
641 if (!fHistMassAntiLambdaOn) {
642 Printf("ERROR: fHistMassAntiLambdaOn not available");
645 fHistArmenterosPodolanskiOff = dynamic_cast<TH2F*> (cRetrievedList->FindObject("fHistArmenterosPodolanskiOff"));
646 if (!fHistArmenterosPodolanskiOff) {
647 Printf("ERROR: fHistArmenterosPodolanskiOff not available");
650 fHistArmenterosPodolanskiOn = dynamic_cast<TH2F*> (cRetrievedList->FindObject("fHistArmenterosPodolanskiOn"));
651 if (!fHistArmenterosPodolanskiOn) {
652 Printf("ERROR: fHistArmenterosPodolanskiOn not available");
657 fHistMassK0sOn->SetMarkerStyle(20);
658 fHistMassK0sOn->DrawCopy("E");
659 fHistMassK0sOff->SetMarkerStyle(24);
660 fHistMassK0sOff->DrawCopy("ESAME");
663 fHistMassLambdaOn->SetMarkerStyle(20);
664 fHistMassLambdaOn->DrawCopy("E");
665 fHistMassLambdaOff->SetMarkerStyle(24);
666 fHistMassLambdaOff->DrawCopy("ESAME");
669 fHistMassAntiLambdaOn->SetMarkerStyle(20);
670 fHistMassAntiLambdaOn->DrawCopy("E");
671 fHistMassAntiLambdaOff->SetMarkerStyle(24);
672 fHistMassAntiLambdaOff->DrawCopy("ESAME");
675 fHistArmenterosPodolanskiOff->DrawCopy("COL2Z");
677 fHistArmenterosPodolanskiOn->DrawCopy("COL2Z");