/************************************************************************** * Author: Boris Hippolyte. * * Contributors are mentioned in the code where appropriate. * * * * Permission to use, copy, modify and distribute this software and its * * documentation strictly for non-commercial purposes is hereby granted * * without fee, provided that the above copyright notice appears in all * * copies and that both the copyright notice and this permission notice * * appear in the supporting documentation. The authors make no claims * * about the suitability of this software for any purpose. It is * * provided "as is" without express or implied warranty. * **************************************************************************/ //----------------------------------------------------------------- // AliAnalysisTaskCheckV0 class // This task is for QAing the V0s from ESD/AOD // Origin: B.H. Nov2007, hippolyt@in2p3.fr //----------------------------------------------------------------- #include "TList.h" #include "TH1F.h" #include "TH2F.h" #include "TStyle.h" #include "TCanvas.h" #include "TLegend.h" #include "AliAnalysisTaskSE.h" #include "AliAnalysisManager.h" #include "AliInputEventHandler.h" #include "AliESDEvent.h" #include "AliESDVertex.h" #include "AliAODEvent.h" #include "AliESDv0.h" #include "AliAnalysisTaskCheckV0.h" ClassImp(AliAnalysisTaskCheckV0) //________________________________________________________________________ AliAnalysisTaskCheckV0::AliAnalysisTaskCheckV0() : AliAnalysisTaskSE(), fAnalysisType("ESD"), fCollidingSystems(0), fUsePhysicsSelection(0), fMaxPrimaryVtxPosZ(100.), fMinV0Pt(0.), fMaxV0Pt(100.), fMaxV0Rapidity(1.), fMinDaughterTpcClusters(80), fListHist(), fHistPrimaryVertexPosX(0), fHistPrimaryVertexPosY(0), fHistPrimaryVertexPosZ(0), fHistKeptPrimaryVertexPosX(0), fHistKeptPrimaryVertexPosY(0), fHistKeptPrimaryVertexPosZ(0), fHistTrackMultiplicity(0), fHistV0Multiplicity(0), fHistV0OnFlyStatus(0), fHistV0MultiplicityOff(0), fHistV0Chi2Off(0), fHistDcaV0DaughtersOff(0), fHistV0CosineOfPointingAngleOff(0), fHistV0RadiusOff(0),fHistDcaV0ToPrimVertexOff(0), fHistDcaPosToPrimVertexOff(0),fHistDcaNegToPrimVertexOff(0), fHistMassK0sOff(0),fHistMassLambdaOff(0),fHistMassAntiLambdaOff(0), fHistMassK0sOffVsPt(0),fHistMassLambdaOffVsPt(0),fHistMassAntiLambdaOffVsPt(0), fHistArmenterosPodolanskiOff(0), fHistV0MultiplicityOn(0), fHistV0Chi2On(0), fHistDcaV0DaughtersOn(0), fHistV0CosineOfPointingAngleOn(0), fHistV0RadiusOn(0),fHistDcaV0ToPrimVertexOn(0), fHistDcaPosToPrimVertexOn(0),fHistDcaNegToPrimVertexOn(0), fHistMassK0sOn(0),fHistMassLambdaOn(0),fHistMassAntiLambdaOn(0), fHistMassK0sOnVsPt(0),fHistMassLambdaOnVsPt(0),fHistMassAntiLambdaOnVsPt(0), fHistArmenterosPodolanskiOn(0) { // Dummy constructor } //________________________________________________________________________ AliAnalysisTaskCheckV0::AliAnalysisTaskCheckV0(const char *name) : AliAnalysisTaskSE(name), fAnalysisType("ESD"), fCollidingSystems(0), fUsePhysicsSelection(0), fMaxPrimaryVtxPosZ(100.), fMinV0Pt(0.), fMaxV0Pt(100.), fMaxV0Rapidity(1.), fMinDaughterTpcClusters(80), fListHist(), fHistPrimaryVertexPosX(0), fHistPrimaryVertexPosY(0), fHistPrimaryVertexPosZ(0), fHistKeptPrimaryVertexPosX(0), fHistKeptPrimaryVertexPosY(0), fHistKeptPrimaryVertexPosZ(0), fHistTrackMultiplicity(0), fHistV0Multiplicity(0), fHistV0OnFlyStatus(0), fHistV0MultiplicityOff(0), fHistV0Chi2Off(0), fHistDcaV0DaughtersOff(0), fHistV0CosineOfPointingAngleOff(0), fHistV0RadiusOff(0),fHistDcaV0ToPrimVertexOff(0), fHistDcaPosToPrimVertexOff(0),fHistDcaNegToPrimVertexOff(0), fHistMassK0sOff(0),fHistMassLambdaOff(0),fHistMassAntiLambdaOff(0), fHistMassK0sOffVsPt(0),fHistMassLambdaOffVsPt(0),fHistMassAntiLambdaOffVsPt(0), fHistArmenterosPodolanskiOff(0), fHistV0MultiplicityOn(0), fHistV0Chi2On(0), fHistDcaV0DaughtersOn(0), fHistV0CosineOfPointingAngleOn(0), fHistV0RadiusOn(0),fHistDcaV0ToPrimVertexOn(0), fHistDcaPosToPrimVertexOn(0),fHistDcaNegToPrimVertexOn(0), fHistMassK0sOn(0),fHistMassLambdaOn(0),fHistMassAntiLambdaOn(0), fHistMassK0sOnVsPt(0),fHistMassLambdaOnVsPt(0),fHistMassAntiLambdaOnVsPt(0), fHistArmenterosPodolanskiOn(0) { // Constructor // Define output slots only here // Output slot #1 writes into a TList container DefineOutput(1, TList::Class()); } //________________________________________________________________________ AliAnalysisTaskCheckV0::~AliAnalysisTaskCheckV0(){ // Destructor if (fListHist) { delete fListHist; fListHist = 0x0; } } //________________________________________________________________________ void AliAnalysisTaskCheckV0::UserCreateOutputObjects() { // Create histograms // Called once // Distinguish Track and V0 Multiplicity ! fListHist = new TList(); fListHist->SetOwner(); if (!fHistPrimaryVertexPosX) { fHistPrimaryVertexPosX = new TH1F("fHistPrimaryVertexPosX", "Primary vertex position in x;Position in x (cm);Events;",100,-1,1); fListHist->Add(fHistPrimaryVertexPosX); } if (!fHistPrimaryVertexPosY) { fHistPrimaryVertexPosY = new TH1F("fHistPrimaryVertexPosY", "Primary vertex position in y;Position in y (cm);Events;",100,-1,1); fListHist->Add(fHistPrimaryVertexPosY); } if (!fHistPrimaryVertexPosZ) { fHistPrimaryVertexPosZ = new TH1F("fHistPrimaryVertexPosZ", "Primary vertex position in z;Position in z (cm);Events;",100,-1,1); fListHist->Add(fHistPrimaryVertexPosZ); } if (!fHistKeptPrimaryVertexPosX) { fHistKeptPrimaryVertexPosX = new TH1F("fHistKeptPrimaryVertexPosX", "Kept Primary vertex position in x;Position in x (cm);Events;",100,-1,1); fListHist->Add(fHistKeptPrimaryVertexPosX); } if (!fHistKeptPrimaryVertexPosY) { fHistKeptPrimaryVertexPosY = new TH1F("fHistKeptPrimaryVertexPosY", "Kept Primary vertex position in y;Position in y (cm);Events;",100,-1,1); fListHist->Add(fHistKeptPrimaryVertexPosY); } if (!fHistKeptPrimaryVertexPosZ) { fHistKeptPrimaryVertexPosZ = new TH1F("fHistKeptPrimaryVertexPosZ", "Kept Primary vertex position in z;Position in z (cm);Events;",100,-1,1); fListHist->Add(fHistKeptPrimaryVertexPosZ); } if (!fHistTrackMultiplicity) { if (fCollidingSystems) fHistTrackMultiplicity = new TH1F("fHistTrackMultiplicity", "Multiplicity distribution;Number of tracks;Events", 200, 0, 40000); else fHistTrackMultiplicity = new TH1F("fHistTrackMultiplicity", "Multiplicity distribution;Number of tracks;Events", 250, 0, 250); fListHist->Add(fHistTrackMultiplicity); } if (!fHistV0Multiplicity) { if (fCollidingSystems) fHistV0Multiplicity = new TH1F("fHistV0Multiplicity", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000); else fHistV0Multiplicity = new TH1F("fHistV0Multiplicity", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50); fListHist->Add(fHistV0Multiplicity); } if (!fHistV0OnFlyStatus) { fHistV0OnFlyStatus = new TH1F("fHistV0OnFlyStatus", "V0 On fly status;status;Number of V0s", 3, 0, 3); fListHist->Add(fHistV0OnFlyStatus); } // V0 offline distributions if (!fHistV0MultiplicityOff) { if (fCollidingSystems) fHistV0MultiplicityOff = new TH1F("fHistV0MultiplicityOff", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000); else fHistV0MultiplicityOff = new TH1F("fHistV0MultiplicityOff", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50); fListHist->Add(fHistV0MultiplicityOff); } if (!fHistV0Chi2Off) { fHistV0Chi2Off = new TH1F("fHistV0Chi2Off", "V0 chi2;chi2;Number of V0s", 33, 0, 33); fListHist->Add(fHistV0Chi2Off); } if (!fHistDcaV0DaughtersOff) { fHistDcaV0DaughtersOff = new TH1F("fHistDcaV0DaughtersOff", "DCA between V0 daughters;DCA (cm);Number of V0s", 300, 0, 3); fListHist->Add(fHistDcaV0DaughtersOff); } if (!fHistV0CosineOfPointingAngleOff) { fHistV0CosineOfPointingAngleOff = new TH1F("fHistV0CosineOfPointingAngleOff", "V0 Cosine of Pointing Angle;Number of V0s", 200, 0, 1); fListHist->Add(fHistV0CosineOfPointingAngleOff); } if (!fHistV0RadiusOff) { fHistV0RadiusOff = new TH1F("fHistV0RadiusOff", "V0 decay radius;Radius (cm);Number of V0s", 33, 0, 33); fListHist->Add(fHistV0RadiusOff); } if (!fHistDcaV0ToPrimVertexOff) { fHistDcaV0ToPrimVertexOff = new TH1F("fHistDcaV0ToPrimVertexOff", "DCA of V0 to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3); fListHist->Add(fHistDcaV0ToPrimVertexOff); } if (!fHistDcaPosToPrimVertexOff) { fHistDcaPosToPrimVertexOff = new TH1F("fHistDcaPosToPrimVertexOff", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3); fListHist->Add(fHistDcaPosToPrimVertexOff); } if (!fHistDcaNegToPrimVertexOff) { fHistDcaNegToPrimVertexOff = new TH1F("fHistDcaNegToPrimVertexOff", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3); fListHist->Add(fHistDcaNegToPrimVertexOff); } if (!fHistMassK0sOff) { fHistMassK0sOff = new TH1F("fHistMassK0sOff","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts",100,0.4,0.6); fListHist->Add(fHistMassK0sOff); } if (!fHistMassLambdaOff) { fHistMassLambdaOff = new TH1F("fHistMassLambdaOff","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts",75,1.05,1.2); fListHist->Add(fHistMassLambdaOff); } if (!fHistMassAntiLambdaOff) { fHistMassAntiLambdaOff = new TH1F("fHistMassAntiLambdaOff","#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts",75,1.05,1.2); fListHist->Add(fHistMassAntiLambdaOff); } if (!fHistMassK0sOffVsPt) { 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); fListHist->Add(fHistMassK0sOffVsPt); } if (!fHistMassLambdaOffVsPt) { 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); fListHist->Add(fHistMassLambdaOffVsPt); } if (!fHistMassAntiLambdaOffVsPt) { 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); fListHist->Add(fHistMassAntiLambdaOffVsPt); } if (!fHistArmenterosPodolanskiOff) { fHistArmenterosPodolanskiOff = new TH2F("fHistArmenterosPodolanskiOff","Armenteros-Podolanski Offline phase space;#alpha;p_{t} arm",200,-1.0,1.0,150,0,0.3); fListHist->Add(fHistArmenterosPodolanskiOff); } // V0 on-the-fly distributions if (!fHistV0MultiplicityOn) { if (fCollidingSystems) fHistV0MultiplicityOn = new TH1F("fHistV0MultiplicityOn", "Multiplicity distribution;Number of V0s;Events", 200, 0, 40000); else fHistV0MultiplicityOn = new TH1F("fHistV0MultiplicityOn", "Multiplicity distribution;Number of V0s;Events", 50, 0, 50); fListHist->Add(fHistV0MultiplicityOn); } if (!fHistV0Chi2On) { fHistV0Chi2On = new TH1F("fHistV0Chi2On", "V0 chi2;chi2;Number of V0s", 33, 0, 33); fListHist->Add(fHistV0Chi2On); } if (!fHistDcaV0DaughtersOn) { fHistDcaV0DaughtersOn = new TH1F("fHistDcaV0DaughtersOn", "DCA between V0 daughters;DCA (cm);Number of V0s", 300, 0, 3); fListHist->Add(fHistDcaV0DaughtersOn); } if (!fHistV0CosineOfPointingAngleOn) { fHistV0CosineOfPointingAngleOn = new TH1F("fHistV0CosineOfPointingAngleOn", "V0 Cosine of Pointing Angle;Number of V0s", 200, 0, 1); fListHist->Add(fHistV0CosineOfPointingAngleOn); } if (!fHistV0RadiusOn) { fHistV0RadiusOn = new TH1F("fHistV0RadiusOn", "V0 decay radius;Radius (cm);Number of V0s", 33, 0, 33); fListHist->Add(fHistV0RadiusOn); } if (!fHistDcaV0ToPrimVertexOn) { fHistDcaV0ToPrimVertexOn = new TH1F("fHistDcaV0ToPrimVertexOn", "DCA of V0 to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3); fListHist->Add(fHistDcaV0ToPrimVertexOn); } if (!fHistDcaPosToPrimVertexOn) { fHistDcaPosToPrimVertexOn = new TH1F("fHistDcaPosToPrimVertexOn", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3); fListHist->Add(fHistDcaPosToPrimVertexOn); } if (!fHistDcaNegToPrimVertexOn) { fHistDcaNegToPrimVertexOn = new TH1F("fHistDcaNegToPrimVertexOn", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Number of V0s", 300, 0, 3); fListHist->Add(fHistDcaNegToPrimVertexOn); } if (!fHistMassK0sOn) { fHistMassK0sOn = new TH1F("fHistMassK0sOn","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts",100,0.4,0.6); fListHist->Add(fHistMassK0sOn); } if (!fHistMassLambdaOn) { fHistMassLambdaOn = new TH1F("fHistMassLambdaOn","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts",75,1.05,1.2); fListHist->Add(fHistMassLambdaOn); } if (!fHistMassAntiLambdaOn) { fHistMassAntiLambdaOn = new TH1F("fHistMassAntiLambdaOn","#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts",75,1.05,1.2); fListHist->Add(fHistMassAntiLambdaOn); } if (!fHistMassK0sOnVsPt) { 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); fListHist->Add(fHistMassK0sOnVsPt); } if (!fHistMassLambdaOnVsPt) { 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); fListHist->Add(fHistMassLambdaOnVsPt); } if (!fHistMassAntiLambdaOnVsPt) { 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); fListHist->Add(fHistMassAntiLambdaOnVsPt); } if (!fHistArmenterosPodolanskiOn) { fHistArmenterosPodolanskiOn = new TH2F("fHistArmenterosPodolanskiOn","Armenteros-Podolanski Onthefly phase space;#alpha;p_{t} arm",200,-1.0,1.0,150,0,0.3); fListHist->Add(fHistArmenterosPodolanskiOn); } // Post output data. PostData(1, fListHist); } //________________________________________________________________________ void AliAnalysisTaskCheckV0::UserExec(Option_t *) { // Main loop // Called for each event AliVEvent* lEvent = InputEvent(); if (!lEvent) { Printf("ERROR: Event not available"); return; } Bool_t isSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected(); if ((fUsePhysicsSelection)&&(!isSelected)) return; fHistTrackMultiplicity->Fill(lEvent->GetNumberOfTracks()); Double_t tPrimaryVtxPosition[3]; Int_t nv0s = 0; nv0s = lEvent->GetNumberOfV0s(); // Printf("CheckV0 analysis task: There are %d v0s in this event",nv0s); Int_t lOnFlyStatus = 0, nv0sOn = 0, nv0sOff = 0; Double_t lChi2V0 = 0; Double_t lDcaV0Daughters = 0, lDcaV0ToPrimVertex = 0; Double_t lDcaPosToPrimVertex = 0, lDcaNegToPrimVertex = 0; Double_t lV0CosineOfPointingAngle = 0; Double_t lV0Radius = 0, lPt = 0; Double_t lRapK0Short = 0, lRapLambda = 0; Double_t lInvMassK0s = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0; Double_t lAlphaV0 = 0, lPtArmV0 = 0; const AliVVertex *primaryVtx = lEvent->GetPrimaryVertex(); tPrimaryVtxPosition[0] = primaryVtx->GetX(); tPrimaryVtxPosition[1] = primaryVtx->GetY(); tPrimaryVtxPosition[2] = primaryVtx->GetZ(); fHistPrimaryVertexPosX->Fill(tPrimaryVtxPosition[0]); fHistPrimaryVertexPosY->Fill(tPrimaryVtxPosition[1]); fHistPrimaryVertexPosZ->Fill(tPrimaryVtxPosition[2]); if (TMath::Abs(tPrimaryVtxPosition[2])Fill(tPrimaryVtxPosition[0]); fHistKeptPrimaryVertexPosY->Fill(tPrimaryVtxPosition[1]); fHistKeptPrimaryVertexPosZ->Fill(tPrimaryVtxPosition[2]); if(fAnalysisType == "ESD") { Double_t lMagneticField = ((AliESDEvent*)lEvent)->GetMagneticField(); for (Int_t iV0 = 0; iV0 < nv0s; iV0++) {// This is the begining of the V0 loop AliESDv0 *v0 = ((AliESDEvent*)lEvent)->GetV0(iV0); if (!v0) continue; Double_t tDecayVertexV0[3]; v0->GetXYZ(tDecayVertexV0[0],tDecayVertexV0[1],tDecayVertexV0[2]); lV0Radius = TMath::Sqrt(tDecayVertexV0[0]*tDecayVertexV0[0]+tDecayVertexV0[1]*tDecayVertexV0[1]); lPt = v0->Pt(); lRapK0Short = v0->RapK0Short(); lRapLambda = v0->RapLambda(); if ((lPtGetPindex()); UInt_t lKeyNeg = (UInt_t)TMath::Abs(v0->GetNindex()); Double_t lMomPos[3]; v0->GetPPxPyPz(lMomPos[0],lMomPos[1],lMomPos[2]); Double_t lMomNeg[3]; v0->GetNPxPyPz(lMomNeg[0],lMomNeg[1],lMomNeg[2]); AliESDtrack *pTrack=((AliESDEvent*)lEvent)->GetTrack(lKeyPos); AliESDtrack *nTrack=((AliESDEvent*)lEvent)->GetTrack(lKeyNeg); if (!pTrack || !nTrack) { Printf("ERROR: Could not retreive one of the daughter track"); continue; } // Filter like-sign V0 (next: add counter and distribution) if ( pTrack->GetSign() == nTrack->GetSign()){ continue; } // WARNING: the following selections cannot be done for AOD yet... // Tracks quality cuts if ( ( (pTrack->GetTPCNcls()) < fMinDaughterTpcClusters ) || ( (nTrack->GetTPCNcls()) < fMinDaughterTpcClusters ) ) continue; // TPC refit condition (done during reconstruction for Offline but not for On-the-fly) if( !(pTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue; if( !(nTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue; lDcaPosToPrimVertex = TMath::Abs(pTrack->GetD(tPrimaryVtxPosition[0], tPrimaryVtxPosition[1], lMagneticField) ); lDcaNegToPrimVertex = TMath::Abs(nTrack->GetD(tPrimaryVtxPosition[0], tPrimaryVtxPosition[1], lMagneticField) ); lOnFlyStatus = v0->GetOnFlyStatus(); lChi2V0 = v0->GetChi2V0(); lDcaV0Daughters = v0->GetDcaV0Daughters(); lDcaV0ToPrimVertex = v0->GetD(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]); lV0CosineOfPointingAngle = v0->GetV0CosineOfPointingAngle(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]); // Getting invariant mass infos directly from ESD v0->ChangeMassHypothesis(310); lInvMassK0s = v0->GetEffMass(); v0->ChangeMassHypothesis(3122); lInvMassLambda = v0->GetEffMass(); v0->ChangeMassHypothesis(-3122); lInvMassAntiLambda = v0->GetEffMass(); lAlphaV0 = v0->AlphaV0(); lPtArmV0 = v0->PtArmV0(); fHistV0OnFlyStatus->Fill(lOnFlyStatus); if(!lOnFlyStatus){ nv0sOff++; fHistV0Chi2Off->Fill(lChi2V0); fHistDcaV0ToPrimVertexOff->Fill(lDcaV0ToPrimVertex); fHistDcaV0DaughtersOff->Fill(lDcaV0Daughters); fHistV0CosineOfPointingAngleOff->Fill(lV0CosineOfPointingAngle); fHistV0RadiusOff->Fill(lV0Radius); fHistDcaPosToPrimVertexOff->Fill(lDcaPosToPrimVertex); fHistDcaNegToPrimVertexOff->Fill(lDcaNegToPrimVertex); // Filling invariant mass histos for all candidates fHistMassK0sOff->Fill(lInvMassK0s); fHistMassLambdaOff->Fill(lInvMassLambda); fHistMassAntiLambdaOff->Fill(lInvMassAntiLambda); if (TMath::Abs(lRapK0Short)Fill(lPt,lInvMassK0s); if (TMath::Abs(lRapLambda)Fill(lPt,lInvMassLambda); fHistMassAntiLambdaOffVsPt->Fill(lPt,lInvMassAntiLambda); } fHistArmenterosPodolanskiOff->Fill(lAlphaV0,lPtArmV0); } else { nv0sOn++; fHistV0Chi2On->Fill(lChi2V0); fHistDcaV0ToPrimVertexOn->Fill(lDcaV0ToPrimVertex); fHistDcaV0DaughtersOn->Fill(lDcaV0Daughters); fHistV0CosineOfPointingAngleOn->Fill(lV0CosineOfPointingAngle); fHistV0RadiusOn->Fill(lV0Radius); fHistDcaPosToPrimVertexOn->Fill(lDcaPosToPrimVertex); fHistDcaNegToPrimVertexOn->Fill(lDcaNegToPrimVertex); // Filling invariant mass histos for all candidates fHistMassK0sOn->Fill(lInvMassK0s); fHistMassLambdaOn->Fill(lInvMassLambda); fHistMassAntiLambdaOn->Fill(lInvMassAntiLambda); if (TMath::Abs(lRapK0Short)Fill(lPt,lInvMassK0s); if (TMath::Abs(lRapLambda)Fill(lPt,lInvMassLambda); fHistMassAntiLambdaOnVsPt->Fill(lPt,lInvMassAntiLambda); } fHistArmenterosPodolanskiOn->Fill(lAlphaV0,lPtArmV0); } }// This is the end of the V0 loop } // end of "ESD" analysis else if(fAnalysisType == "AOD") { for (Int_t iV0 = 0; iV0 < nv0s; iV0++) {// This is the begining of the V0 loop AliAODv0 *v0 = ((AliAODEvent*)lEvent)->GetV0(iV0); if (!v0) continue; lV0Radius = v0->RadiusV0(); lPt = v0->Pt(); lRapK0Short = v0->RapK0Short(); lRapLambda = v0->RapLambda(); if ((lPtDcaPosToPrimVertex(); lDcaNegToPrimVertex = v0->DcaNegToPrimVertex(); // propose getOnFlyStatus() = -1 for like-sign lOnFlyStatus = v0->GetOnFlyStatus(); lChi2V0 = v0->Chi2V0(); lDcaV0Daughters = v0->DcaV0Daughters(); lDcaV0ToPrimVertex = v0->DcaV0ToPrimVertex(); lV0CosineOfPointingAngle = v0->CosPointingAngle(tPrimaryVtxPosition); lInvMassK0s = v0->MassK0Short(); lInvMassLambda = v0->MassLambda(); lInvMassAntiLambda = v0->MassAntiLambda(); lAlphaV0 = v0->AlphaV0(); lPtArmV0 = v0->PtArmV0(); fHistV0OnFlyStatus->Fill(lOnFlyStatus); if(!lOnFlyStatus){ nv0sOff++; fHistV0Chi2Off->Fill(lChi2V0); fHistDcaV0ToPrimVertexOff->Fill(lDcaV0ToPrimVertex); fHistDcaV0DaughtersOff->Fill(lDcaV0Daughters); fHistV0CosineOfPointingAngleOff->Fill(lV0CosineOfPointingAngle); fHistV0RadiusOff->Fill(lV0Radius); fHistDcaPosToPrimVertexOff->Fill(lDcaPosToPrimVertex); fHistDcaNegToPrimVertexOff->Fill(lDcaNegToPrimVertex); // Filling invariant mass histos for all candidates fHistMassK0sOff->Fill(lInvMassK0s); fHistMassLambdaOff->Fill(lInvMassLambda); fHistMassAntiLambdaOff->Fill(lInvMassAntiLambda); if (TMath::Abs(lRapK0Short)Fill(lPt,lInvMassK0s); if (TMath::Abs(lRapLambda)Fill(lPt,lInvMassLambda); fHistMassAntiLambdaOffVsPt->Fill(lPt,lInvMassAntiLambda); } fHistArmenterosPodolanskiOff->Fill(lAlphaV0,lPtArmV0); } else { nv0sOn++; fHistV0Chi2On->Fill(lChi2V0); fHistDcaV0ToPrimVertexOn->Fill(lDcaV0ToPrimVertex); fHistDcaV0DaughtersOn->Fill(lDcaV0Daughters); fHistV0CosineOfPointingAngleOn->Fill(lV0CosineOfPointingAngle); fHistV0RadiusOn->Fill(lV0Radius); fHistDcaPosToPrimVertexOn->Fill(lDcaPosToPrimVertex); fHistDcaNegToPrimVertexOn->Fill(lDcaNegToPrimVertex); // Filling invariant mass histos for all candidates fHistMassK0sOn->Fill(lInvMassK0s); fHistMassLambdaOn->Fill(lInvMassLambda); fHistMassAntiLambdaOn->Fill(lInvMassAntiLambda); if (TMath::Abs(lRapK0Short)Fill(lPt,lInvMassK0s); if (TMath::Abs(lRapLambda)Fill(lPt,lInvMassLambda); fHistMassAntiLambdaOnVsPt->Fill(lPt,lInvMassAntiLambda); } fHistArmenterosPodolanskiOn->Fill(lAlphaV0,lPtArmV0); } }// This is the end of the V0 loop } // end of "AOD" analysis fHistV0Multiplicity->Fill(nv0s); fHistV0MultiplicityOff->Fill(nv0sOff); fHistV0MultiplicityOn->Fill(nv0sOn); }// end of event selection // Post output data. PostData(1, fListHist); } //________________________________________________________________________ void AliAnalysisTaskCheckV0::Terminate(Option_t *) { // Draw result to the screen // Called once at the end of the query TList *cRetrievedList = 0x0; cRetrievedList = (TList*)GetOutputData(1); if(!cRetrievedList){ AliWarning("ERROR - AliAnalysisTaskCheckV0: output data container list not available\n"); return; } // Implement a decent style TStyle *myStyle = new TStyle("myStyle","my style"); Int_t font = 42; myStyle->SetCanvasColor(10); myStyle->SetStatColor(10); myStyle->SetPadColor(10); myStyle->SetDrawBorder(0); myStyle->SetCanvasBorderMode(0); myStyle->SetPadBorderMode(0); myStyle->SetTextFont(font); myStyle->SetStatFont(font); myStyle->SetLabelFont(font,"xyz"); myStyle->SetTitleFont(font); myStyle->SetPalette(1,0); myStyle->cd(); fHistTrackMultiplicity = dynamic_cast (cRetrievedList->FindObject("fHistTrackMultiplicity")); if (!fHistTrackMultiplicity) { Printf("ERROR: fHistTrackMultiplicity not available"); return; } fHistV0Multiplicity = dynamic_cast (cRetrievedList->FindObject("fHistV0Multiplicity")); if (!fHistV0Multiplicity) { Printf("ERROR: fHistV0Multiplicity not available"); return; } fHistV0MultiplicityOff = dynamic_cast (cRetrievedList->FindObject("fHistV0MultiplicityOff")); if (!fHistV0MultiplicityOff) { Printf("ERROR: fHistV0MultiplicityOff not available"); return; } fHistV0MultiplicityOn = dynamic_cast (cRetrievedList->FindObject("fHistV0MultiplicityOn")); if (!fHistV0MultiplicityOn) { Printf("ERROR: fHistV0MultiplicityOn not available"); return; } TCanvas *canCheckV0 = new TCanvas("AliAnalysisTaskCheckV0","Check V0",10,10,510,700); canCheckV0->Divide(2,3); if (fHistTrackMultiplicity->GetMaximum() > 0.) canCheckV0->cd(1)->SetLogy(); fHistTrackMultiplicity->SetMarkerStyle(26); fHistTrackMultiplicity->DrawCopy("E"); fHistV0Multiplicity->SetMarkerStyle(25); fHistV0Multiplicity->DrawCopy("ESAME"); fHistV0MultiplicityOff->SetMarkerStyle(24); fHistV0MultiplicityOff->DrawCopy("ESAME"); fHistV0MultiplicityOn->SetMarkerStyle(20); fHistV0MultiplicityOn->DrawCopy("ESAME"); TLegend *legendMultiplicity = new TLegend(0.5,0.5,0.75,0.75); legendMultiplicity->AddEntry(fHistTrackMultiplicity,"tracks"); legendMultiplicity->AddEntry(fHistV0Multiplicity,"all V^{0}"); legendMultiplicity->AddEntry(fHistV0MultiplicityOff,"offline V^{0}"); legendMultiplicity->AddEntry(fHistV0MultiplicityOn,"onthefly V^{0}"); legendMultiplicity->Draw(); fHistMassK0sOff = dynamic_cast (cRetrievedList->FindObject("fHistMassK0sOff")); if (!fHistMassK0sOff) { Printf("ERROR: fHistMassK0sOff not available"); return; } fHistMassK0sOn = dynamic_cast (cRetrievedList->FindObject("fHistMassK0sOn")); if (!fHistMassK0sOn) { Printf("ERROR: fHistMassK0sOn not available"); return; } fHistMassLambdaOff = dynamic_cast (cRetrievedList->FindObject("fHistMassLambdaOff")); if (!fHistMassLambdaOff) { Printf("ERROR: fHistMassLambdaOff not available"); return; } fHistMassLambdaOn = dynamic_cast (cRetrievedList->FindObject("fHistMassLambdaOn")); if (!fHistMassLambdaOn) { Printf("ERROR: fHistMassLambdaOn not available"); return; } fHistMassAntiLambdaOff = dynamic_cast (cRetrievedList->FindObject("fHistMassAntiLambdaOff")); if (!fHistMassAntiLambdaOff) { Printf("ERROR: fHistMassAntiLambdaOff not available"); return; } fHistMassAntiLambdaOn = dynamic_cast (cRetrievedList->FindObject("fHistMassAntiLambdaOn")); if (!fHistMassAntiLambdaOn) { Printf("ERROR: fHistMassAntiLambdaOn not available"); return; } fHistArmenterosPodolanskiOff = dynamic_cast (cRetrievedList->FindObject("fHistArmenterosPodolanskiOff")); if (!fHistArmenterosPodolanskiOff) { Printf("ERROR: fHistArmenterosPodolanskiOff not available"); return; } fHistArmenterosPodolanskiOn = dynamic_cast (cRetrievedList->FindObject("fHistArmenterosPodolanskiOn")); if (!fHistArmenterosPodolanskiOn) { Printf("ERROR: fHistArmenterosPodolanskiOn not available"); return; } canCheckV0->cd(2); fHistMassK0sOn->SetMarkerStyle(20); fHistMassK0sOn->DrawCopy("E"); fHistMassK0sOff->SetMarkerStyle(24); fHistMassK0sOff->DrawCopy("ESAME"); canCheckV0->cd(3); fHistMassLambdaOn->SetMarkerStyle(20); fHistMassLambdaOn->DrawCopy("E"); fHistMassLambdaOff->SetMarkerStyle(24); fHistMassLambdaOff->DrawCopy("ESAME"); canCheckV0->cd(4); fHistMassAntiLambdaOn->SetMarkerStyle(20); fHistMassAntiLambdaOn->DrawCopy("E"); fHistMassAntiLambdaOff->SetMarkerStyle(24); fHistMassAntiLambdaOff->DrawCopy("ESAME"); canCheckV0->cd(5); fHistArmenterosPodolanskiOff->DrawCopy("COL2Z"); canCheckV0->cd(6); fHistArmenterosPodolanskiOn->DrawCopy("COL2Z"); }