PWG2/SPECTRA/AliAnalysisTaskCheckV0.cxx

   1 /**************************************************************************
   2  * Author: Boris Hippolyte.                                               *
   3  * Contributors are mentioned in the code where appropriate.              *
   4  *                                                                        *
   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  **************************************************************************/
  13
  14 //-----------------------------------------------------------------
  15 //                 AliAnalysisTaskCheckV0 class
  16 //            This task is for QAing the V0s from ESD/AOD
  17 //              Origin: B.H. Nov2007, hippolyt@in2p3.fr
  18 //-----------------------------------------------------------------
  19 #include "TList.h"
  20 #include "TH1F.h"
  21 #include "TCanvas.h"
  22 #include "TLegend.h"
  23
  24 #include "AliAnalysisTaskSE.h"
  25
  26 #include "AliESDEvent.h"
  27 #include "AliESDVertex.h"
  28 #include "AliAODEvent.h"
  29 #include "AliAODVertex.h"
  30
  31 #include "AliESDv0.h"
  32
  33 #include "AliAnalysisTaskCheckV0.h"
  34
  35 ClassImp(AliAnalysisTaskCheckV0)
  36
  37 //________________________________________________________________________
  38 AliAnalysisTaskCheckV0::AliAnalysisTaskCheckV0()
  39   : AliAnalysisTaskSE(), fAnalysisType("ESD"), fCollidingSystems(0), fListHist(),
  40     fHistPrimaryVertexPosX(0), fHistPrimaryVertexPosY(0), fHistPrimaryVertexPosZ(0),
  41     fHistTrackMultiplicity(0), fHistV0Multiplicity(0), fHistV0OnFlyStatus(0),
  42     fHistV0MultiplicityOff(0), fHistV0Chi2Off(0),
  43     fHistDcaV0DaughtersOff(0), fHistV0CosineOfPointingAngleOff(0),
  44     fHistV0RadiusOff(0),fHistDcaV0ToPrimVertexOff(0),
  45     fHistDcaPosToPrimVertexOff(0),fHistDcaNegToPrimVertexOff(0),
  46     fHistMassK0Off(0),fHistMassLambdaOff(0),fHistMassAntiLambdaOff(0),
  47     fHistV0MultiplicityOn(0), fHistV0Chi2On(0),
  48     fHistDcaV0DaughtersOn(0), fHistV0CosineOfPointingAngleOn(0),
  49     fHistV0RadiusOn(0),fHistDcaV0ToPrimVertexOn(0),
  50     fHistDcaPosToPrimVertexOn(0),fHistDcaNegToPrimVertexOn(0),
  51     fHistMassK0On(0),fHistMassLambdaOn(0),fHistMassAntiLambdaOn(0)
  52 {
  53   // Dummy constructor
  54 }
  55 //________________________________________________________________________
  56 AliAnalysisTaskCheckV0::AliAnalysisTaskCheckV0(const char *name)
  57   : AliAnalysisTaskSE(name), fAnalysisType("ESD"), fCollidingSystems(0), fListHist(),
  58     fHistPrimaryVertexPosX(0), fHistPrimaryVertexPosY(0), fHistPrimaryVertexPosZ(0),
  59     fHistTrackMultiplicity(0), fHistV0Multiplicity(0), fHistV0OnFlyStatus(0),
  60     fHistV0MultiplicityOff(0), fHistV0Chi2Off(0),
  61     fHistDcaV0DaughtersOff(0), fHistV0CosineOfPointingAngleOff(0),
  62     fHistV0RadiusOff(0),fHistDcaV0ToPrimVertexOff(0),
  63     fHistDcaPosToPrimVertexOff(0),fHistDcaNegToPrimVertexOff(0),
  64     fHistMassK0Off(0),fHistMassLambdaOff(0),fHistMassAntiLambdaOff(0),
  65     fHistV0MultiplicityOn(0), fHistV0Chi2On(0),
  66     fHistDcaV0DaughtersOn(0), fHistV0CosineOfPointingAngleOn(0),
  67     fHistV0RadiusOn(0),fHistDcaV0ToPrimVertexOn(0),
  68     fHistDcaPosToPrimVertexOn(0),fHistDcaNegToPrimVertexOn(0),
  69     fHistMassK0On(0),fHistMassLambdaOn(0),fHistMassAntiLambdaOn(0)
  70 {
  71   // Constructor
  72   // Define output slots only here
  73   // Output slot #1 writes into a TList container
  74   DefineOutput(1, TList::Class());
  75 }
  76
  77 //________________________________________________________________________
  78 void AliAnalysisTaskCheckV0::UserCreateOutputObjects()
  79 {
  80   // Create histograms
  81   // Called once
  82
  83   // Distinguish Track and V0 Multiplicity !
  84
  85   fListHist = new TList();
  86
  87   if (!fHistPrimaryVertexPosX) {
  88     fHistPrimaryVertexPosX = new TH1F("fHistPrimaryVertexPosX", "Primary vertex position in x;Position in x (cm);Events;",100,-1,1);
  89     fListHist->Add(fHistPrimaryVertexPosX);
  90   }
  91   if (!fHistPrimaryVertexPosY) {
  92     fHistPrimaryVertexPosY = new TH1F("fHistPrimaryVertexPosY", "Primary vertex position in y;Position in y (cm);Events;",100,-1,1);
  93     fListHist->Add(fHistPrimaryVertexPosY);
  94   }
  95   if (!fHistPrimaryVertexPosZ) {
  96     fHistPrimaryVertexPosZ = new TH1F("fHistPrimaryVertexPosZ", "Primary vertex position in z;Position in z (cm);Events;",100,-1,1);
  97     fListHist->Add(fHistPrimaryVertexPosZ);
  98   }
  99
 100   if (!fHistTrackMultiplicity) {
 101     if (fCollidingSystems)
 102       fHistTrackMultiplicity = new TH1F("fHistTrackMultiplicity", "Multiplicity distribution;Number of tracks;Events", 200, 0, 40000);
 103     else
 104       fHistTrackMultiplicity = new TH1F("fHistTrackMultiplicity", "Multiplicity distribution;Number of tracks;Events", 250, 0, 250);
 105     fListHist->Add(fHistTrackMultiplicity);
 106   }
 107   if (!fHistV0Multiplicity) {
 108     if (fCollidingSystems)
 109       fHistV0Multiplicity = new TH1F("fHistV0Multiplicity", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000);
 110     else
 111       fHistV0Multiplicity = new TH1F("fHistV0Multiplicity", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50);
 112     fListHist->Add(fHistV0Multiplicity);
 113   }
 114   if (!fHistV0OnFlyStatus) {
 115     fHistV0OnFlyStatus = new TH1F("fHistV0OnFlyStatus", "V0 On fly status;status;Number of V0s", 3, 0, 3);
 116     fListHist->Add(fHistV0OnFlyStatus);
 117   }
 118
 119   // V0 offline distributions
 120   if (!fHistV0MultiplicityOff) {
 121     if (fCollidingSystems)
 122       fHistV0MultiplicityOff = new TH1F("fHistV0MultiplicityOff", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000);
 123     else
 124       fHistV0MultiplicityOff = new TH1F("fHistV0MultiplicityOff", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50);
 125     fListHist->Add(fHistV0MultiplicityOff);
 126   }
 127   if (!fHistV0Chi2Off) {
 128     fHistV0Chi2Off = new TH1F("fHistV0Chi2Off", "V0 chi2;chi2;Number of V0s", 33, 0, 33);
 129     fListHist->Add(fHistV0Chi2Off);
 130   }
 131   if (!fHistDcaV0DaughtersOff) {
 132     fHistDcaV0DaughtersOff = new TH1F("fHistDcaV0DaughtersOff", "DCA between V0 daughters;DCA (cm);Number of V0s", 300, 0, 3);
 133     fListHist->Add(fHistDcaV0DaughtersOff);
 134   }
 135   if (!fHistV0CosineOfPointingAngleOff) {
 136     fHistV0CosineOfPointingAngleOff = new TH1F("fHistV0CosineOfPointingAngleOff", "V0 Cosine of Pointing Angle;Number of V0s", 200, 0, 1);
 137     fListHist->Add(fHistV0CosineOfPointingAngleOff);
 138   }
 139   if (!fHistV0RadiusOff) {
 140     fHistV0RadiusOff = new TH1F("fHistV0RadiusOff", "V0 decay radius;Radius (cm);Number of V0s", 33, 0, 33);
 141     fListHist->Add(fHistV0RadiusOff);
 142   }
 143   if (!fHistDcaV0ToPrimVertexOff) {
 144     fHistDcaV0ToPrimVertexOff = new TH1F("fHistDcaV0ToPrimVertexOff", "DCA of V0 to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
 145     fListHist->Add(fHistDcaV0ToPrimVertexOff);
 146   }
 147   if (!fHistDcaPosToPrimVertexOff) {
 148     fHistDcaPosToPrimVertexOff = new TH1F("fHistDcaPosToPrimVertexOff", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
 149     fListHist->Add(fHistDcaPosToPrimVertexOff);
 150   }
 151   if (!fHistDcaNegToPrimVertexOff) {
 152     fHistDcaNegToPrimVertexOff = new TH1F("fHistDcaNegToPrimVertexOff", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
 153     fListHist->Add(fHistDcaNegToPrimVertexOff);
 154   }
 155
 156   if (!fHistMassK0Off) {
 157     fHistMassK0Off = new TH1F("fHistMassK0Off","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts",100,0.4,0.6);
 158     fListHist->Add(fHistMassK0Off);
 159   }
 160   if (!fHistMassLambdaOff) {
 161     fHistMassLambdaOff = new TH1F("fHistMassLambdaOff","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts",75,1.05,1.2);
 162     fListHist->Add(fHistMassLambdaOff);
 163   }
 164   if (!fHistMassAntiLambdaOff) {
 165     fHistMassAntiLambdaOff = new TH1F("fHistMassAntiLambdaOff","#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts",75,1.05,1.2);
 166     fListHist->Add(fHistMassAntiLambdaOff);
 167   }
 168
 169   // V0 on-the-fly distributions
 170   if (!fHistV0MultiplicityOn) {
 171     if (fCollidingSystems)
 172       fHistV0MultiplicityOn = new TH1F("fHistV0MultiplicityOn", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000);
 173     else
 174       fHistV0MultiplicityOn = new TH1F("fHistV0MultiplicityOn", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50);
 175     fListHist->Add(fHistV0MultiplicityOn);
 176   }
 177   if (!fHistV0Chi2On) {
 178     fHistV0Chi2On = new TH1F("fHistV0Chi2On", "V0 chi2;chi2;Number of V0s", 33, 0, 33);
 179     fListHist->Add(fHistV0Chi2On);
 180   }
 181   if (!fHistDcaV0DaughtersOn) {
 182     fHistDcaV0DaughtersOn = new TH1F("fHistDcaV0DaughtersOn", "DCA between V0 daughters;DCA (cm);Number of V0s", 300, 0, 3);
 183     fListHist->Add(fHistDcaV0DaughtersOn);
 184   }
 185   if (!fHistV0CosineOfPointingAngleOn) {
 186     fHistV0CosineOfPointingAngleOn = new TH1F("fHistV0CosineOfPointingAngleOn", "V0 Cosine of Pointing Angle;Number of V0s", 200, 0, 1);
 187     fListHist->Add(fHistV0CosineOfPointingAngleOn);
 188   }
 189   if (!fHistV0RadiusOn) {
 190     fHistV0RadiusOn = new TH1F("fHistV0RadiusOn", "V0 decay radius;Radius (cm);Number of V0s", 33, 0, 33);
 191     fListHist->Add(fHistV0RadiusOn);
 192   }
 193   if (!fHistDcaV0ToPrimVertexOn) {
 194     fHistDcaV0ToPrimVertexOn = new TH1F("fHistDcaV0ToPrimVertexOn", "DCA of V0 to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
 195     fListHist->Add(fHistDcaV0ToPrimVertexOn);
 196   }
 197   if (!fHistDcaPosToPrimVertexOn) {
 198     fHistDcaPosToPrimVertexOn = new TH1F("fHistDcaPosToPrimVertexOn", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
 199     fListHist->Add(fHistDcaPosToPrimVertexOn);
 200   }
 201   if (!fHistDcaNegToPrimVertexOn) {
 202     fHistDcaNegToPrimVertexOn = new TH1F("fHistDcaNegToPrimVertexOn", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3);
 203     fListHist->Add(fHistDcaNegToPrimVertexOn);
 204   }
 205
 206   if (!fHistMassK0On) {
 207     fHistMassK0On = new TH1F("fHistMassK0On","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts",100,0.4,0.6);
 208     fListHist->Add(fHistMassK0On);
 209   }
 210   if (!fHistMassLambdaOn) {
 211     fHistMassLambdaOn = new TH1F("fHistMassLambdaOn","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts",75,1.05,1.2);
 212     fListHist->Add(fHistMassLambdaOn);
 213   }
 214   if (!fHistMassAntiLambdaOn) {
 215     fHistMassAntiLambdaOn = new TH1F("fHistMassAntiLambdaOn","#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts",75,1.05,1.2);
 216     fListHist->Add(fHistMassAntiLambdaOn);
 217   }
 218
 219 }
 220
 221 //________________________________________________________________________
 222 void AliAnalysisTaskCheckV0::UserExec(Option_t *)
 223 {
 224   // Main loop
 225   // Called for each event
 226   AliVEvent* lEvent = InputEvent();
 227   if (!lEvent) {
 228     Printf("ERROR: Event not available");
 229     return;
 230   }
 231   fHistTrackMultiplicity->Fill(lEvent->GetNumberOfTracks());
 232
 233   Double_t tPrimaryVtxPosition[3];
 234   Int_t nv0s = 0;
 235   nv0s = lEvent->GetNumberOfV0s();
 236   Printf("CheckV0 analysis task: There are %d v0s in this event",nv0s);
 237
 238   Int_t    lOnFlyStatus = 0, nv0sOn = 0, nv0sOff = 0;
 239   Double_t lChi2V0 = 0;
 240   Double_t lDcaV0Daughters = 0, lDcaV0ToPrimVertex = 0;
 241   Double_t lDcaPosToPrimVertex = 0, lDcaNegToPrimVertex = 0;
 242   Double_t lV0CosineOfPointingAngle = 0;
 243   Double_t lV0Radius = 0;
 244   Double_t lInvMassK0 = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0;
 245
 246   if(fAnalysisType == "ESD") {
 247
 248     const AliESDVertex *primaryVtx = ((AliESDEvent*)lEvent)->GetPrimaryVertex();
 249     tPrimaryVtxPosition[0] = primaryVtx->GetXv();
 250     tPrimaryVtxPosition[1] = primaryVtx->GetYv();
 251     tPrimaryVtxPosition[2] = primaryVtx->GetZv();
 252
 253     fHistPrimaryVertexPosX->Fill(tPrimaryVtxPosition[0]);
 254     fHistPrimaryVertexPosY->Fill(tPrimaryVtxPosition[1]);
 255     fHistPrimaryVertexPosZ->Fill(tPrimaryVtxPosition[2]);
 256
 257     for (Int_t iV0 = 0; iV0 < nv0s; iV0++)
 258       {// This is the begining of the V0 loop
 259         AliESDv0 *v0 = ((AliESDEvent*)lEvent)->GetV0(iV0);
 260         if (!v0) continue;
 261
 262         Double_t tDecayVertexV0[3]; v0->GetXYZ(tDecayVertexV0[0],tDecayVertexV0[1],tDecayVertexV0[2]);
 263
 264         lV0Radius = TMath::Sqrt(tDecayVertexV0[0]*tDecayVertexV0[0]+tDecayVertexV0[1]*tDecayVertexV0[1]);
 265
 266         UInt_t lKeyPos = (UInt_t)TMath::Abs(v0->GetPindex());
 267         UInt_t lKeyNeg = (UInt_t)TMath::Abs(v0->GetNindex());
 268
 269         Double_t lMomPos[3]; v0->GetPPxPyPz(lMomPos[0],lMomPos[1],lMomPos[2]);
 270         Double_t lMomNeg[3]; v0->GetNPxPyPz(lMomNeg[0],lMomNeg[1],lMomNeg[2]);
 271
 272         AliESDtrack *pTrack=((AliESDEvent*)lEvent)->GetTrack(lKeyPos);
 273         AliESDtrack *nTrack=((AliESDEvent*)lEvent)->GetTrack(lKeyNeg);
 274         if (!pTrack || !nTrack) {
 275           Printf("ERROR: Could not retreive one of the daughter track");
 276           continue;
 277         }
 278
 279         Float_t tDcaPosToPrimVertex[2];
 280         if(pTrack) pTrack->GetImpactParameters(tDcaPosToPrimVertex[0],tDcaPosToPrimVertex[1]);
 281         else { tDcaPosToPrimVertex[0]=999.;  tDcaPosToPrimVertex[1]=999.;}
 282         lDcaPosToPrimVertex = TMath::Sqrt(tDcaPosToPrimVertex[0]*tDcaPosToPrimVertex[0]+tDcaPosToPrimVertex[1]*tDcaPosToPrimVertex[1]);
 283
 284         Float_t tDcaNegToPrimVertex[2];
 285         if(nTrack) nTrack->GetImpactParameters(tDcaNegToPrimVertex[0],tDcaNegToPrimVertex[1]);
 286         else { tDcaNegToPrimVertex[0]=999.;  tDcaNegToPrimVertex[1]=999.;}
 287         lDcaNegToPrimVertex = TMath::Sqrt(tDcaNegToPrimVertex[0]*tDcaNegToPrimVertex[0]+tDcaNegToPrimVertex[1]*tDcaNegToPrimVertex[1]);
 288
 289
 290         lOnFlyStatus = v0->GetOnFlyStatus();
 291         lChi2V0 = v0->GetChi2V0();
 292         lDcaV0Daughters = v0->GetDcaV0Daughters();
 293         lDcaV0ToPrimVertex = v0->GetD(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]);
 294         lV0CosineOfPointingAngle = v0->GetV0CosineOfPointingAngle(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]);
 295
 296         // Getting invariant mass infos directly from ESD
 297         v0->ChangeMassHypothesis(310);
 298         lInvMassK0 = v0->GetEffMass();
 299         v0->ChangeMassHypothesis(3122);
 300         lInvMassLambda = v0->GetEffMass();
 301         v0->ChangeMassHypothesis(-3122);
 302         lInvMassAntiLambda = v0->GetEffMass();
 303
 304         fHistV0OnFlyStatus->Fill(lOnFlyStatus);
 305         if(!lOnFlyStatus){
 306           nv0sOff++;
 307           fHistV0Chi2Off->Fill(lChi2V0);
 308           fHistDcaV0ToPrimVertexOff->Fill(lDcaV0ToPrimVertex);
 309           fHistDcaV0DaughtersOff->Fill(lDcaV0Daughters);
 310           fHistV0CosineOfPointingAngleOff->Fill(lV0CosineOfPointingAngle);
 311
 312           fHistV0RadiusOff->Fill(lV0Radius);
 313           fHistDcaPosToPrimVertexOff->Fill(lDcaPosToPrimVertex);
 314           fHistDcaNegToPrimVertexOff->Fill(lDcaNegToPrimVertex);
 315
 316           // Filling invariant mass histos for all candidates
 317           fHistMassK0Off->Fill(lInvMassK0);
 318           fHistMassLambdaOff->Fill(lInvMassLambda);
 319           fHistMassAntiLambdaOff->Fill(lInvMassAntiLambda);
 320         }
 321         else {
 322           nv0sOn++;
 323           fHistV0Chi2On->Fill(lChi2V0);
 324           fHistDcaV0ToPrimVertexOn->Fill(lDcaV0ToPrimVertex);
 325           fHistDcaV0DaughtersOn->Fill(lDcaV0Daughters);
 326           fHistV0CosineOfPointingAngleOn->Fill(lV0CosineOfPointingAngle);
 327
 328           fHistV0RadiusOn->Fill(lV0Radius);
 329           fHistDcaPosToPrimVertexOn->Fill(lDcaPosToPrimVertex);
 330           fHistDcaNegToPrimVertexOn->Fill(lDcaNegToPrimVertex);
 331
 332           // Filling invariant mass histos for all candidates
 333           fHistMassK0On->Fill(lInvMassK0);
 334           fHistMassLambdaOn->Fill(lInvMassLambda);
 335           fHistMassAntiLambdaOn->Fill(lInvMassAntiLambda);
 336         }
 337       }// This is the end of the V0 loop
 338   } // end of "ESD" analysis
 339
 340   else if(fAnalysisType == "AOD") {
 341
 342     const AliAODVertex *primaryVtx = ((AliAODEvent*)lEvent)->GetPrimaryVertex();
 343     tPrimaryVtxPosition[0] = primaryVtx->GetX();
 344     tPrimaryVtxPosition[1] = primaryVtx->GetY();
 345     tPrimaryVtxPosition[2] = primaryVtx->GetZ();
 346
 347     fHistPrimaryVertexPosX->Fill(tPrimaryVtxPosition[0]);
 348     fHistPrimaryVertexPosY->Fill(tPrimaryVtxPosition[1]);
 349     fHistPrimaryVertexPosZ->Fill(tPrimaryVtxPosition[2]);
 350
 351     for (Int_t iV0 = 0; iV0 < nv0s; iV0++)
 352       {// This is the begining of the V0 loop
 353         AliAODv0 *v0 = ((AliAODEvent*)lEvent)->GetV0(iV0);
 354         if (!v0) continue;
 355
 356         lV0Radius = v0->RadiusV0();
 357         lDcaPosToPrimVertex = v0->DcaPosToPrimVertex();
 358         lDcaNegToPrimVertex = v0->DcaNegToPrimVertex();
 359
 360
 361         lOnFlyStatus = v0->GetOnFlyStatus();
 362         lChi2V0 = v0->Chi2V0();
 363         lDcaV0Daughters = v0->DcaV0Daughters();
 364         lDcaV0ToPrimVertex = v0->DcaV0ToPrimVertex();
 365         lV0CosineOfPointingAngle = v0->CosPointingAngle(tPrimaryVtxPosition);
 366
 367         lInvMassK0 = v0->MassK0Short();
 368         lInvMassLambda = v0->MassLambda();
 369         lInvMassAntiLambda = v0->MassAntiLambda();
 370
 371         fHistV0OnFlyStatus->Fill(lOnFlyStatus);
 372         if(!lOnFlyStatus){
 373           nv0sOff++;
 374           fHistV0Chi2Off->Fill(lChi2V0);
 375           fHistDcaV0ToPrimVertexOff->Fill(lDcaV0ToPrimVertex);
 376           fHistDcaV0DaughtersOff->Fill(lDcaV0Daughters);
 377           fHistV0CosineOfPointingAngleOff->Fill(lV0CosineOfPointingAngle);
 378
 379           fHistV0RadiusOff->Fill(lV0Radius);
 380           fHistDcaPosToPrimVertexOff->Fill(lDcaPosToPrimVertex);
 381           fHistDcaNegToPrimVertexOff->Fill(lDcaNegToPrimVertex);
 382
 383           // Filling invariant mass histos for all candidates
 384           fHistMassK0Off->Fill(lInvMassK0);
 385           fHistMassLambdaOff->Fill(lInvMassLambda);
 386           fHistMassAntiLambdaOff->Fill(lInvMassAntiLambda);
 387         }
 388         else {
 389           nv0sOn++;
 390           fHistV0Chi2On->Fill(lChi2V0);
 391           fHistDcaV0ToPrimVertexOn->Fill(lDcaV0ToPrimVertex);
 392           fHistDcaV0DaughtersOn->Fill(lDcaV0Daughters);
 393           fHistV0CosineOfPointingAngleOn->Fill(lV0CosineOfPointingAngle);
 394
 395           fHistV0RadiusOn->Fill(lV0Radius);
 396           fHistDcaPosToPrimVertexOn->Fill(lDcaPosToPrimVertex);
 397           fHistDcaNegToPrimVertexOn->Fill(lDcaNegToPrimVertex);
 398
 399           // Filling invariant mass histos for all candidates
 400           fHistMassK0On->Fill(lInvMassK0);
 401           fHistMassLambdaOn->Fill(lInvMassLambda);
 402           fHistMassAntiLambdaOn->Fill(lInvMassAntiLambda);
 403         }
 404       }// This is the end of the V0 loop
 405   } // end of "AOD" analysis
 406
 407   fHistV0Multiplicity->Fill(nv0s);
 408   fHistV0MultiplicityOff->Fill(nv0sOff);
 409   fHistV0MultiplicityOn->Fill(nv0sOn);
 410
 411   // Post output data.
 412   PostData(1, fListHist);
 413 }
 414
 415 //________________________________________________________________________
 416 void AliAnalysisTaskCheckV0::Terminate(Option_t *)
 417 {
 418   // Draw result to the screen
 419   // Called once at the end of the query
 420
 421   fHistTrackMultiplicity = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistTrackMultiplicity"));
 422   if (!fHistTrackMultiplicity) {
 423     Printf("ERROR: fHistTrackMultiplicity not available");
 424     return;
 425   }
 426   fHistV0Multiplicity = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistV0Multiplicity"));
 427   if (!fHistV0Multiplicity) {
 428     Printf("ERROR: fHistV0Multiplicity not available");
 429     return;
 430   }
 431   fHistV0MultiplicityOff = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistV0MultiplicityOff"));
 432   if (!fHistV0MultiplicityOff) {
 433     Printf("ERROR: fHistV0MultiplicityOff not available");
 434     return;
 435   }
 436   fHistV0MultiplicityOn = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistV0MultiplicityOn"));
 437   if (!fHistV0MultiplicityOn) {
 438     Printf("ERROR: fHistV0MultiplicityOn not available");
 439     return;
 440   }
 441
 442   TCanvas *canCheckV0 = new TCanvas("AliAnalysisTaskCheckV0","Multiplicity",10,10,510,510);
 443   canCheckV0->Divide(2,2);
 444   if (fHistTrackMultiplicity->GetMaximum() > 0.) canCheckV0->cd(1)->SetLogy();
 445   fHistTrackMultiplicity->SetMarkerStyle(26);
 446   fHistTrackMultiplicity->DrawCopy("E");
 447   fHistV0Multiplicity->SetMarkerStyle(25);
 448   fHistV0Multiplicity->DrawCopy("ESAME");
 449   fHistV0MultiplicityOff->SetMarkerStyle(24);
 450   fHistV0MultiplicityOff->DrawCopy("ESAME");
 451   fHistV0MultiplicityOn->SetMarkerStyle(20);
 452   fHistV0MultiplicityOn->DrawCopy("ESAME");
 453
 454   TLegend *legendMultiplicity = new TLegend(0.4,0.4,0.65,0.6);
 455   legendMultiplicity->AddEntry(fHistTrackMultiplicity,"tracks");
 456   legendMultiplicity->AddEntry(fHistV0Multiplicity,"all V^{0}");
 457   legendMultiplicity->AddEntry(fHistV0MultiplicityOff,"offline V^{0}");
 458   legendMultiplicity->AddEntry(fHistV0MultiplicityOn,"onthefly V^{0}");
 459   legendMultiplicity->Draw();
 460
 461   fHistMassK0Off = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistMassK0Off"));
 462   if (!fHistMassK0Off) {
 463     Printf("ERROR: fHistMassK0Off not available");
 464     return;
 465   }
 466   fHistMassK0On = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistMassK0On"));
 467   if (!fHistMassK0On) {
 468     Printf("ERROR: fHistMassK0On not available");
 469     return;
 470   }
 471   fHistMassLambdaOff = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistMassLambdaOff"));
 472   if (!fHistMassLambdaOff) {
 473     Printf("ERROR: fHistMassLambdaOff not available");
 474     return;
 475   }
 476   fHistMassLambdaOn = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistMassLambdaOn"));
 477   if (!fHistMassLambdaOn) {
 478     Printf("ERROR: fHistMassLambdaOn not available");
 479     return;
 480   }
 481   fHistMassAntiLambdaOff = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistMassAntiLambdaOff"));
 482   if (!fHistMassAntiLambdaOff) {
 483     Printf("ERROR: fHistMassAntiLambdaOff not available");
 484     return;
 485   }
 486   fHistMassAntiLambdaOn = dynamic_cast<TH1F*> (((TList*)GetOutputData(1))->FindObject("fHistMassAntiLambdaOn"));
 487   if (!fHistMassAntiLambdaOn) {
 488     Printf("ERROR: fHistMassAntiLambdaOn not available");
 489     return;
 490   }
 491
 492   canCheckV0->cd(2);
 493   fHistMassK0Off->SetMarkerStyle(24);
 494   fHistMassK0Off->DrawCopy("E");
 495   fHistMassK0On->SetMarkerStyle(20);
 496   fHistMassK0On->DrawCopy("ESAME");
 497
 498   canCheckV0->cd(3);
 499   fHistMassLambdaOff->SetMarkerStyle(24);
 500   fHistMassLambdaOff->DrawCopy("E");
 501   fHistMassLambdaOn->SetMarkerStyle(20);
 502   fHistMassLambdaOn->DrawCopy("ESAME");
 503
 504   canCheckV0->cd(4);
 505   fHistMassAntiLambdaOff->SetMarkerStyle(24);
 506   fHistMassAntiLambdaOff->DrawCopy("E");
 507   fHistMassAntiLambdaOn->SetMarkerStyle(20);
 508   fHistMassAntiLambdaOn->DrawCopy("ESAME");
 509
 510 }