Taking into account that only 1 or 2 values may be present for the
[u/mrichter/AliRoot.git] / PWG2 / SPECTRA / AliAnalysisTaskESDDedx.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 //                 AliAnalysisTaskESDCheckV0 class
16 //            This task is for QAing the dE/dx from the ESD
17 //              Origin: B.H. Nov2007, hippolyt@in2p3.fr
18 //-----------------------------------------------------------------
19
20 //-----------------------------------------------------------------
21 //    ---> Next upgrades
22 //      1) extent the use of fMidPseudoRapidityFlag to primaries
23 //      2) discuss the GetSigmaToVertex(AliESDtrack*)
24 //      3) decide the kind of refit to be used
25 //-----------------------------------------------------------------
26
27 #include "TChain.h"
28 #include "TTree.h"
29 #include "TList.h"
30 #include "TH1F.h"
31 #include "TH2F.h"
32 #include "TCanvas.h"
33 #include "TVector3.h"
34
35 #include "AliAnalysisTask.h"
36 #include "AliAnalysisManager.h"
37
38 #include "AliESDEvent.h"
39 #include "AliESDInputHandler.h"
40
41 #include "AliESDVertex.h"
42 #include "AliESDv0.h"
43
44 #include "AliAnalysisTaskESDDedx.h"
45
46 ClassImp(AliAnalysisTaskESDDedx)
47
48 //________________________________________________________________________
49   AliAnalysisTaskESDDedx::AliAnalysisTaskESDDedx(const char    *rName,
50                                                  const Bool_t   rAllConstrainedFlag,
51                                                  const Bool_t   rMidPseudoRapidityFlag,
52                                                  const Bool_t   rSelTrackRemoveKink,
53                                                  const Bool_t   rSelTrackWithOnTheFlyV0,
54                                                  const Int_t    rSelTrackMinClustersTPC,
55                                                  const Int_t    rSelTrackMinClustersITS,
56                                                  const Float_t  rSelTrackMaxChi2PerClusterTPC,
57                                                  const Float_t  rSelTrackMaxChi2PerClusterITS,
58                                                  const Double_t rSelTrackMaxCov11,
59                                                  const Double_t rSelTrackMaxCov22,
60                                                  const Double_t rSelTrackMaxCov33,
61                                                  const Double_t rSelTrackMaxCov44,
62                                                  const Double_t rSelTrackMaxCov55,
63                                                  const Double_t rSelV0MaxDcaDaughters,
64                                                  const Double_t rSelV0MinDecayLength)
65
66     : AliAnalysisTask(rName, ""), fESD(0), fListHist(), fHistPtot(0),
67
68     fHistMultiplicity(0), fHistTPCDedxVsMomentum(0), fHistITSDedxVsMomentum(0),
69     fHistMassK0(0), fHistMassLambda(0), fHistMassAntiLambda(0),
70     fHistTPCDedxVsMomPosK0(0), fHistTPCDedxVsMomNegK0(0),
71     fHistTPCDedxVsMomPosLambda(0), fHistTPCDedxVsMomNegLambda(0),
72     fHistTPCDedxVsMomPosAntiLambda(0), fHistTPCDedxVsMomNegAntiLambda(0),
73     fHistDiffInOutMomentum(0), fHistDiffPrimOutMomentum(0),
74     fHistDiffPrimMeanMomentum(0), fHistPercPrimMeanMomentum(0), fHistPrimEta(0),
75     fHistPercPrimMeanMomentumVsEta(0), fHistPercPrimMeanMomentumVsPrim(0),
76
77     fHistMultiplicityCuts(0), fHistTPCDedxVsMomentumCuts(0), fHistITSDedxVsMomentumCuts(0),
78     fHistMassK0Cuts(0), fHistMassLambdaCuts(0), fHistMassAntiLambdaCuts(0), 
79     fHistTPCDedxVsMomPosK0Cuts(0), fHistTPCDedxVsMomNegK0Cuts(0), 
80     fHistTPCDedxVsMomPosLambdaCuts(0), fHistTPCDedxVsMomNegLambdaCuts(0),
81     fHistTPCDedxVsMomPosAntiLambdaCuts(0), fHistTPCDedxVsMomNegAntiLambdaCuts(0),
82     fHistDiffInOutMomentumCuts(0), fHistDiffPrimOutMomentumCuts(0),
83     fHistDiffPrimMeanMomentumCuts(0), fHistPercPrimMeanMomentumCuts(0), fHistPrimEtaCuts(0),
84     fHistPercPrimMeanMomentumVsEtaCuts(0), fHistPercPrimMeanMomentumVsPrimCuts(0),
85
86     fAllConstrainedFlag(rAllConstrainedFlag), fMidPseudoRapidityFlag(rMidPseudoRapidityFlag),
87
88     fSelTrackRemoveKink(rSelTrackRemoveKink), fSelTrackWithOnTheFlyV0(rSelTrackWithOnTheFlyV0),
89     fSelTrackMinClustersTPC(rSelTrackMinClustersTPC), fSelTrackMinClustersITS(rSelTrackMinClustersITS),
90     fSelTrackMaxChi2PerClusterTPC(rSelTrackMaxChi2PerClusterTPC), fSelTrackMaxChi2PerClusterITS(rSelTrackMaxChi2PerClusterITS),
91     fSelTrackMaxCov11(rSelTrackMaxCov11), fSelTrackMaxCov22(rSelTrackMaxCov22), fSelTrackMaxCov33(rSelTrackMaxCov33),
92     fSelTrackMaxCov44(rSelTrackMaxCov44), fSelTrackMaxCov55(rSelTrackMaxCov55),
93     fSelV0MaxDcaDaughters(rSelV0MaxDcaDaughters), fSelV0MinDecayLength(rSelV0MinDecayLength)
94 {
95   // Constructor
96
97   // Define input and output slots here
98   // Input slot #0 works with a TChain
99   DefineInput(0, TChain::Class());
100   // Output slot #0 writes into a TH1 container
101   DefineOutput(0, TH1F::Class());
102   // Output slot #1 writes into a TList container
103   DefineOutput(1, TList::Class());
104 }
105
106 //________________________________________________________________________
107 void AliAnalysisTaskESDDedx::ConnectInputData(Option_t *) 
108 {
109   // Connect ESD or AOD here
110   // Called once
111
112   TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
113   if (!tree) {
114     Printf("ERROR: Could not read chain from input slot 0");
115   } else {
116     // Disable all branches and enable only the needed ones
117     // The next two lines are different when data produced as AliESDEvent is read
118     tree->SetBranchStatus("*", kFALSE);
119     tree->SetBranchStatus("fTracks.*", kTRUE);
120     tree->SetBranchStatus("fV0s.*", kTRUE);
121
122     AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
123
124     if (!esdH) {
125       Printf("ERROR: Could not get ESDInputHandler");
126     } else
127       fESD = esdH->GetEvent();
128   }
129 }
130
131 //________________________________________________________________________
132 void AliAnalysisTaskESDDedx::CreateOutputObjects()
133 {
134   // Create histograms
135   // Called once
136   fListHist = new TList();
137   if (!fHistPtot) {
138     fHistPtot = new TH1F("fHistPtot", "P_{tot} distribution;P_{tot} (GeV/c);dN/dP_{tot} (c/GeV)", 15, 0.1, 3.1);
139     fHistPtot->SetMarkerStyle(kFullCircle);
140     fListHist->Add(fHistPtot);
141   }
142   if (!fHistMultiplicity) {
143     fHistMultiplicity = new TH1F("fHistMultiplicity", "Multiplicity distribution;Number of tracks;Events", 250, 0, 250);
144     fHistMultiplicity->SetMarkerStyle(kFullCircle);
145     fListHist->Add(fHistMultiplicity);
146   }
147   if (!fHistTPCDedxVsMomentum) {
148     fHistTPCDedxVsMomentum = new TH2F("h2TPCDedxVsMomentum","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
149     fListHist->Add(fHistTPCDedxVsMomentum);
150   }
151   if (!fHistITSDedxVsMomentum) {
152     fHistITSDedxVsMomentum = new TH2F("h2ITSDedxVsMomentum","Bethe-Bloch Distribution for ITS;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
153     fListHist->Add(fHistITSDedxVsMomentum);
154   }
155   if (!fHistMassK0) {
156     fHistMassK0 = new TH1F("h1MassK0","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts",100,0.4,0.6);
157     fListHist->Add(fHistMassK0);
158   }
159   if (!fHistMassLambda) {
160     fHistMassLambda = new TH1F("h1MassLambda","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts",75,1.05,1.2);
161     fListHist->Add(fHistMassLambda);
162   }
163   if (!fHistMassAntiLambda) {
164     fHistMassAntiLambda = new TH1F("h1MassAntiLambda","#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts",75,1.05,1.2);
165     fListHist->Add(fHistMassAntiLambda);
166   }
167   if (!fHistTPCDedxVsMomPosK0) {
168     fHistTPCDedxVsMomPosK0 = new TH2F("h2TPCDedxVsMomPosK0","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
169     fListHist->Add(fHistTPCDedxVsMomPosK0);
170   }
171   if (!fHistTPCDedxVsMomNegK0) {
172     fHistTPCDedxVsMomNegK0 = new TH2F("h2TPCDedxVsMomNegK0","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
173     fListHist->Add(fHistTPCDedxVsMomNegK0);
174   }
175   if (!fHistTPCDedxVsMomPosLambda) {
176     fHistTPCDedxVsMomPosLambda = new TH2F("h2TPCDedxVsMomPosLambda","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
177     fListHist->Add(fHistTPCDedxVsMomPosLambda);
178   }
179   if (!fHistTPCDedxVsMomNegLambda) {
180     fHistTPCDedxVsMomNegLambda = new TH2F("h2TPCDedxVsMomNegLambda","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
181     fListHist->Add(fHistTPCDedxVsMomNegLambda);
182   }
183   if (!fHistTPCDedxVsMomPosAntiLambda) {
184     fHistTPCDedxVsMomPosAntiLambda = new TH2F("h2TPCDedxVsMomPosAntiLambda","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
185     fListHist->Add(fHistTPCDedxVsMomPosAntiLambda);
186   }
187   if (!fHistTPCDedxVsMomNegAntiLambda) {
188     fHistTPCDedxVsMomNegAntiLambda = new TH2F("h2TPCDedxVsMomNegAntiLambda","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
189     fListHist->Add(fHistTPCDedxVsMomNegAntiLambda);
190   }
191   if (!fHistDiffInOutMomentum) {
192     fHistDiffInOutMomentum = new TH1F("h1DiffInOutMomentum","Momentum Difference In-Out;Momentum (GeV/c);Counts",200,-0.1,0.1); 
193     fListHist->Add(fHistDiffInOutMomentum);
194   }
195   if (!fHistDiffPrimOutMomentum) {
196     fHistDiffPrimOutMomentum = new TH1F("h1DiffPrimOutMomentum","Momentum Difference Prim-Out;Momentum (GeV/c);Counts",200,-0.1,0.1); 
197     fListHist->Add(fHistDiffPrimOutMomentum);
198   }
199   if (!fHistDiffPrimMeanMomentum) {
200     fHistDiffPrimMeanMomentum = new TH1F("h1DiffPrimMeanMomentum","Momentum Difference Prim-Mean;Momentum (GeV/c);Counts",200,-0.1,0.1); 
201     fListHist->Add(fHistDiffPrimMeanMomentum);
202   }
203   if (!fHistPercPrimMeanMomentum) {
204     fHistPercPrimMeanMomentum = new TH1F("h1PercPrimMeanMomentum","Momentum Percentage (Prim-Mean)/Prim;(Primary-Mean)/Primary (%);Counts",200,-10,10); 
205     fListHist->Add(fHistPercPrimMeanMomentum);
206   }
207   if (!fHistPrimEta) {
208     fHistPrimEta = new TH1F("h1PrimEta","Pseudorapidity Distribution (Primaries);#eta;Counts",300,-1.5,1.5); 
209     fListHist->Add(fHistPrimEta);
210   }
211   if (!fHistPercPrimMeanMomentumVsEta) {
212     fHistPercPrimMeanMomentumVsEta = new TH2F("h2PercPrimMeanMomentumVsEta","Momentum Percentage (Prim-Mean)/Prim vs #eta;#eta;(Primary-Mean)/Primary (%)",100,-1.5,1.5,100,-10,10); 
213     fListHist->Add(fHistPercPrimMeanMomentumVsEta);
214   }
215   if (!fHistPercPrimMeanMomentumVsPrim) {
216     fHistPercPrimMeanMomentumVsPrim = new TH2F("h2PercPrimMeanMomentumVsPrim","Momentum Percentage (Prim-Mean)/Prim vs Prim;Momentum (GeV/c);(Primary-Mean)/Primary (%)",1500,0,15,100,-10,10); 
217     fListHist->Add(fHistPercPrimMeanMomentumVsPrim);
218   }
219   // Histograms after selections
220   if (!fHistMultiplicityCuts) {
221     fHistMultiplicityCuts = new TH1F("h1HistMultiplicityCuts","Number of Good tracks;Number of tracks;Event",201,-0.5,200.5);
222     fListHist->Add(fHistMultiplicityCuts);
223   }
224   if (!fHistTPCDedxVsMomentumCuts) {
225     fHistTPCDedxVsMomentumCuts = new TH2F("h2TPCDedxVsMomentumCuts","Bethe-Bloch Distribution for TPC w/cuts;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
226     fListHist->Add(fHistTPCDedxVsMomentumCuts);
227   }
228   if (!fHistITSDedxVsMomentumCuts) {
229     fHistITSDedxVsMomentumCuts = new TH2F("h2ITSDedxVsMomentumCuts","Bethe-Bloch Distribution for ITS w/cuts;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
230     fListHist->Add(fHistITSDedxVsMomentumCuts);
231   }
232   if (!fHistMassK0Cuts) {
233     fHistMassK0Cuts = new TH1F("h1MassK0Cuts","K^{0} candidates;M(#pi^{+}#pi^{-}) (GeV/c^{2});Counts",100,0.4,0.6);
234     fListHist->Add(fHistMassK0Cuts);
235   }
236   if (!fHistMassLambdaCuts) {
237     fHistMassLambdaCuts = new TH1F("h1MassLambdaCuts","#Lambda^{0} candidates;M(p#pi^{-}) (GeV/c^{2});Counts",75,1.05,1.2);
238     fListHist->Add(fHistMassLambdaCuts);
239   }
240   if (!fHistMassAntiLambdaCuts) {
241     fHistMassAntiLambdaCuts = new TH1F("h1MassAntiLambdaCuts","#bar{#Lambda}^{0} candidates;M(#bar{p}#pi^{+}) (GeV/c^{2});Counts",75,1.05,1.2);
242     fListHist->Add(fHistMassAntiLambdaCuts);
243   }
244   if (!fHistTPCDedxVsMomPosK0Cuts) {
245     fHistTPCDedxVsMomPosK0Cuts = new TH2F("h2TPCDedxVsMomPosK0Cuts","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
246     fListHist->Add(fHistTPCDedxVsMomPosK0Cuts);
247   }
248   if (!fHistTPCDedxVsMomNegK0Cuts) {
249     fHistTPCDedxVsMomNegK0Cuts = new TH2F("h2TPCDedxVsMomNegK0Cuts","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
250     fListHist->Add(fHistTPCDedxVsMomNegK0Cuts);
251   }
252   if (!fHistTPCDedxVsMomPosLambdaCuts) {
253     fHistTPCDedxVsMomPosLambdaCuts = new TH2F("h2TPCDedxVsMomPosLambdaCuts","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
254     fListHist->Add(fHistTPCDedxVsMomPosLambdaCuts);
255   }
256   if (!fHistTPCDedxVsMomNegLambdaCuts) {
257     fHistTPCDedxVsMomNegLambdaCuts = new TH2F("h2TPCDedxVsMomNegLambdaCuts","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
258     fListHist->Add(fHistTPCDedxVsMomNegLambdaCuts);
259   }
260   if (!fHistTPCDedxVsMomPosAntiLambdaCuts) {
261     fHistTPCDedxVsMomPosAntiLambdaCuts = new TH2F("h2TPCDedxVsMomPosAntiLambdaCuts","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
262     fListHist->Add(fHistTPCDedxVsMomPosAntiLambdaCuts);
263   }
264   if (!fHistTPCDedxVsMomNegAntiLambdaCuts) {
265     fHistTPCDedxVsMomNegAntiLambdaCuts = new TH2F("h2TPCDedxVsMomNegAntiLambdaCuts","Bethe-Bloch Distribution for TPC;Momentum (GeV/c);dE/dx (A.U.)",1500,0,15,100,0,100);
266     fListHist->Add(fHistTPCDedxVsMomNegAntiLambdaCuts);
267   }
268   if (!fHistDiffInOutMomentumCuts) {
269     fHistDiffInOutMomentumCuts = new TH1F("h1DiffInOutMomentumCuts","Momentum Difference In-Out;Momentum (GeV/c);Counts",200,-0.1,0.1); 
270     fListHist->Add(fHistDiffInOutMomentumCuts);
271   }
272   if (!fHistDiffPrimOutMomentumCuts) {
273     fHistDiffPrimOutMomentumCuts = new TH1F("h1DiffPrimOutMomentumCuts","Momentum Difference Prim-Out;Momentum (GeV/c);Counts",200,-0.1,0.1); 
274     fListHist->Add(fHistDiffPrimOutMomentumCuts);
275   }
276   if (!fHistDiffPrimMeanMomentumCuts) {
277     fHistDiffPrimMeanMomentumCuts = new TH1F("h1DiffPrimMeanMomentumCuts","Momentum Difference Prim-Mean;Momentum (GeV/c);Counts",200,-0.1,0.1); 
278     fListHist->Add(fHistDiffPrimMeanMomentumCuts);
279   }
280   if (!fHistPercPrimMeanMomentumCuts) {
281     fHistPercPrimMeanMomentumCuts = new TH1F("h1PercPrimMeanMomentumCuts","Momentum Percentage (Prim-Mean)/Prim;(Primary-Mean)/Primary (%);Counts",200,-10,10); 
282     fListHist->Add(fHistPercPrimMeanMomentumCuts);
283   }
284   if (!fHistPrimEtaCuts) {
285     fHistPrimEtaCuts = new TH1F("h1PrimEtaCuts","Pseudorapidity Distribution (Primaries);#eta;Counts",300,-1.5,1.5); 
286     fListHist->Add(fHistPrimEtaCuts);
287   }
288   if (!fHistPercPrimMeanMomentumVsEtaCuts) {
289     fHistPercPrimMeanMomentumVsEtaCuts = new TH2F("h2PercPrimMeanMomentumVsEtaCuts","Momentum Percentage (Prim-Mean)/Prim vs #eta;#eta;(Primary-Mean)/Primary (%)",100,-1.5,1.5,100,-10,10); 
290     fListHist->Add(fHistPercPrimMeanMomentumVsEtaCuts);
291   }
292   if (!fHistPercPrimMeanMomentumVsPrimCuts) {
293     fHistPercPrimMeanMomentumVsPrimCuts = new TH2F("h2PercPrimMeanMomentumVsPrimCuts","Momentum Percentage (Prim-Mean)/Prim vs Prim;Momentum (GeV/c);(Primary-Mean)/Primary (%)",1500,0,15,100,-10,10); 
294     fListHist->Add(fHistPercPrimMeanMomentumVsPrimCuts);
295   }
296 }
297
298 //________________________________________________________________________
299 void AliAnalysisTaskESDDedx::Exec(Option_t *) 
300 {
301   // Main loop
302   // Called for each event
303
304   if (!fESD) {
305     Printf("ERROR: fESD not available");
306     return;
307   }
308
309   Int_t    nGetTracks        = fESD->GetNumberOfTracks();
310   //  Printf("There are %d tracks in this event", nGetTracks);
311
312   Int_t    nAllTracks        = 0, nGoodTracks       = 0;
313   Double_t lTPCDedx          = 0, lITSDedx          = 0;
314
315   // Track loop
316   for (Int_t iTracks = 0; iTracks < nGetTracks; iTracks++) {
317     AliESDtrack* track = fESD->GetTrack(iTracks);
318     if (!track) {
319       Printf("ERROR: Could not retrieve track %d", iTracks);
320       continue;
321     }
322     fHistPtot->Fill(track->P()); // Fill a ptot spectrum before any selection
323
324     Double_t lPrimvtxMomemtum[3];
325     Bool_t lIsTrackConstrained = track->GetConstrainedPxPyPz(lPrimvtxMomemtum);
326     if (fAllConstrainedFlag && (!lIsTrackConstrained)) continue; // Constrained or not to Prim Vertex.
327
328     const AliExternalTrackParam *lInnerETP = track->GetInnerParam();
329     const AliExternalTrackParam *lOuterETP = track->GetOuterParam();
330     if ((!lInnerETP)||(!lOuterETP)) continue;  // No inner nor outer params for this track.
331
332     Double_t lInnerMomentum = 0, lOuterMomentum = 0, lMeanMomentum = 0;
333     if (lInnerETP) lInnerMomentum = lInnerETP->GetP(); // The "inner" momentum.
334     if (lOuterETP) lOuterMomentum = lOuterETP->GetP(); // The "outer" momentum.
335     if (lInnerETP&&lOuterETP) lMeanMomentum = (lInnerMomentum+lOuterMomentum)/2.; // The "mean" momentum 
336
337     lTPCDedx = track->GetTPCsignal();
338     lITSDedx = track->GetITSsignal();
339     // This needs to be discussed and implemented
340     // nSigmaToVertex = GetSigmaToVertex(track);
341
342     Float_t lPrimPseudoRap = 0, lPrimMomentum = 0;
343     if (lIsTrackConstrained){
344       TVector3 pPrimvtx(lPrimvtxMomemtum);
345       lPrimPseudoRap = pPrimvtx.Eta();
346       lPrimMomentum = pPrimvtx.Mag();
347     }
348
349     if (
350         ((!fAllConstrainedFlag)||(TMath::Abs(lPrimPseudoRap) < 0.5)) &&
351         (lTPCDedx)
352         )
353       // fAllConstrained = 0 -> !fAllConstrained = 1 so ok anyway
354       // fAllConstrained = 1 -> !fAllConstrained = 0 so it depends on eta condition 
355       {
356         nAllTracks++;
357         fHistTPCDedxVsMomentum->Fill(lInnerMomentum,lTPCDedx);
358         fHistDiffInOutMomentum->Fill(lInnerMomentum-lOuterMomentum);
359         if (lIsTrackConstrained){
360           fHistITSDedxVsMomentum->Fill(lPrimMomentum,lITSDedx);
361           fHistDiffPrimOutMomentum->Fill(lPrimMomentum-lOuterMomentum);
362           fHistDiffPrimMeanMomentum->Fill(lPrimMomentum-lMeanMomentum);
363           if (lPrimMomentum){
364             fHistPercPrimMeanMomentum->Fill(100.*(lPrimMomentum-lMeanMomentum)/lPrimMomentum);
365             fHistPercPrimMeanMomentumVsEta->Fill(lPrimPseudoRap,100.*(lPrimMomentum-lMeanMomentum)/lPrimMomentum);
366             fHistPercPrimMeanMomentumVsPrim->Fill(lPrimMomentum,100.*(lPrimMomentum-lMeanMomentum)/lPrimMomentum);
367           }
368           fHistPrimEta->Fill(lPrimPseudoRap);
369         }
370         if(
371            // (!fAllConstrainedFlag || (nSigmaToVertex < 3)) &&
372            (IsAccepted(track))
373            ){
374           fHistTPCDedxVsMomentumCuts->Fill(lInnerMomentum,lTPCDedx);
375           fHistDiffInOutMomentumCuts->Fill(lInnerMomentum-lOuterMomentum);
376           if (lIsTrackConstrained){
377             fHistITSDedxVsMomentumCuts->Fill(lPrimMomentum,lITSDedx);
378             fHistDiffPrimOutMomentumCuts->Fill(lPrimMomentum-lOuterMomentum);
379             fHistDiffPrimMeanMomentumCuts->Fill(lPrimMomentum-lMeanMomentum);
380             if (lPrimMomentum){
381               fHistPercPrimMeanMomentumCuts->Fill(100.*(lPrimMomentum-lMeanMomentum)/lPrimMomentum);
382               fHistPercPrimMeanMomentumVsEtaCuts->Fill(lPrimPseudoRap,100.*(lPrimMomentum-lMeanMomentum)/lPrimMomentum);
383               fHistPercPrimMeanMomentumVsPrimCuts->Fill(lPrimMomentum,100.*(lPrimMomentum-lMeanMomentum)/lPrimMomentum);
384             }
385             fHistPrimEtaCuts->Fill(lPrimPseudoRap);
386           }
387           nGoodTracks++;
388         }
389       }
390   } //track loop 
391   fHistMultiplicity->Fill(nGetTracks);
392   fHistMultiplicityCuts->Fill(nGoodTracks);
393
394   Int_t nv0s = 0;
395   nv0s = fESD->GetNumberOfV0s();
396
397   Int_t    lIndexTrackPos       = 0,  lIndexTrackNeg       = 0;
398   Double_t lTPCDedxPos          = 0,  lTPCDedxNeg          = 0;
399   Float_t lInvMassK0 = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0;
400   for (Int_t iV0 = 0; iV0 < nv0s; iV0++) 
401     {// This is the V0 loop
402       AliESDv0 *v0 = fESD->GetV0(iV0);
403       if (!v0) continue;
404       if (v0->GetOnFlyStatus() != fSelTrackWithOnTheFlyV0) continue;
405
406       const AliESDVertex *lPrimaryVertex = fESD->GetVertex();
407       Double_t tPositionPrimaryVertex[3]; lPrimaryVertex->GetXYZ(tPositionPrimaryVertex);
408       Double_t v0PositionX = 0, v0PositionY = 0, v0PositionZ = 0; v0->GetXYZ(v0PositionX,v0PositionY,v0PositionZ);
409       Double_t v0DecayLength = TMath::Sqrt(
410                                            (v0PositionX-tPositionPrimaryVertex[0])*(v0PositionX-tPositionPrimaryVertex[0])+
411                                            (v0PositionY-tPositionPrimaryVertex[1])*(v0PositionY-tPositionPrimaryVertex[1])+
412                                            (v0PositionZ-tPositionPrimaryVertex[2])*(v0PositionZ-tPositionPrimaryVertex[2])
413                                            );
414       if (v0->GetDcaV0Daughters() > fSelV0MaxDcaDaughters) continue;
415       if (v0DecayLength < fSelV0MinDecayLength) continue;
416
417       // Getting invariant mass infos directly from ESD
418       v0->ChangeMassHypothesis(310);
419       lInvMassK0 = v0->GetEffMass();
420       v0->ChangeMassHypothesis(3122);
421       lInvMassLambda = v0->GetEffMass();
422       v0->ChangeMassHypothesis(-3122);
423       lInvMassAntiLambda = v0->GetEffMass();
424
425       // Filling invariant mass histos for all candidates
426       fHistMassK0->Fill(lInvMassK0);
427       fHistMassLambda->Fill(lInvMassLambda);
428       fHistMassAntiLambda->Fill(lInvMassAntiLambda);
429
430       // Accessing the daughter track infos
431       lIndexTrackPos = TMath::Abs(v0->GetPindex());
432       lIndexTrackNeg = TMath::Abs(v0->GetNindex());
433       AliESDtrack* trackPos = fESD->GetTrack(lIndexTrackPos);
434       AliESDtrack* trackNeg = fESD->GetTrack(lIndexTrackNeg);
435       
436       Double_t lPrimvtxMomPos[3];
437       Bool_t lIsPosConstrained = trackPos->GetConstrainedPxPyPz(lPrimvtxMomPos);
438       if (fAllConstrainedFlag && (!lIsPosConstrained)) continue; // Constrained or not to Prim Vertex.
439
440       Double_t lPrimvtxMomNeg[3];
441       Bool_t lIsNegConstrained = trackNeg->GetConstrainedPxPyPz(lPrimvtxMomNeg);
442       if (fAllConstrainedFlag && (!lIsNegConstrained)) continue; // Constrained or not to Prim Vertex.
443
444       const AliExternalTrackParam *lInnerPosETP = trackPos->GetInnerParam();
445       const AliExternalTrackParam *lInnerNegETP = trackNeg->GetInnerParam();
446       if ((!lInnerPosETP)||(!lInnerNegETP)) continue; // No inner params for at least one track.
447
448       Double_t lInnerMomPos = 0, lInnerMomNeg = 0;
449       if (lInnerPosETP) lInnerMomPos = lInnerPosETP->GetP();
450       if (lInnerNegETP) lInnerMomNeg = lInnerNegETP->GetP();
451
452       lTPCDedxPos = trackPos->GetTPCsignal();
453       lTPCDedxNeg = trackNeg->GetTPCsignal();
454
455       Float_t lPrimPseudoRapPos = 0, lPrimPseudoRapNeg = 0;
456       if (lIsPosConstrained && lIsNegConstrained){
457         TVector3 pPrimPos(lPrimvtxMomPos);
458         TVector3 pPrimNeg(lPrimvtxMomNeg);
459         lPrimPseudoRapPos = pPrimPos.Eta();
460         lPrimPseudoRapNeg = pPrimNeg.Eta();
461       }
462
463       if (TMath::Abs(lInvMassK0-0.497)<0.01) {
464         fHistMassK0Cuts->Fill(lInvMassK0);
465         fHistTPCDedxVsMomPosK0->Fill(lInnerMomPos,lTPCDedxPos);
466         fHistTPCDedxVsMomNegK0->Fill(lInnerMomNeg,lTPCDedxNeg);
467         if (
468             (!fMidPseudoRapidityFlag) || ( TMath::Abs(lPrimPseudoRapPos) < 0.5) &&
469             (IsAccepted(trackPos))
470             )
471           fHistTPCDedxVsMomPosK0Cuts->Fill(lInnerMomPos,lTPCDedxPos);
472         if (
473             (!fMidPseudoRapidityFlag) || ( TMath::Abs(lPrimPseudoRapNeg) < 0.5) &&
474             (IsAccepted(trackNeg))
475             )
476           fHistTPCDedxVsMomNegK0Cuts->Fill(lInnerMomNeg,lTPCDedxNeg);
477       }
478       if (TMath::Abs(lInvMassLambda-1.115)<0.01) {
479         fHistMassLambdaCuts->Fill(lInvMassLambda);
480         fHistTPCDedxVsMomPosLambda->Fill(lInnerMomPos,lTPCDedxPos);
481         fHistTPCDedxVsMomNegLambda->Fill(lInnerMomNeg,lTPCDedxNeg);
482         if (
483             (!fMidPseudoRapidityFlag) || ( TMath::Abs(lPrimPseudoRapPos) < 0.5) &&
484             (IsAccepted(trackPos))
485             )
486           fHistTPCDedxVsMomPosLambdaCuts->Fill(lInnerMomPos,lTPCDedxPos);
487         if (
488             (!fMidPseudoRapidityFlag) || ( TMath::Abs(lPrimPseudoRapNeg) < 0.5) &&
489             (IsAccepted(trackNeg))
490             )
491           fHistTPCDedxVsMomNegLambdaCuts->Fill(lInnerMomNeg,lTPCDedxNeg);
492       }
493       if (TMath::Abs(lInvMassAntiLambda-1.115)<0.01) {
494         fHistMassAntiLambdaCuts->Fill(lInvMassAntiLambda);
495         fHistTPCDedxVsMomPosAntiLambda->Fill(lInnerMomPos,lTPCDedxPos);
496         fHistTPCDedxVsMomNegAntiLambda->Fill(lInnerMomNeg,lTPCDedxNeg);
497         if (
498             (!fMidPseudoRapidityFlag) || ( TMath::Abs(lPrimPseudoRapPos) < 0.5) &&
499             (IsAccepted(trackPos))
500             )
501           fHistTPCDedxVsMomPosAntiLambdaCuts->Fill(lInnerMomPos,lTPCDedxPos);
502         if (
503             (!fMidPseudoRapidityFlag) || ( TMath::Abs(lPrimPseudoRapNeg) < 0.5) &&
504             (IsAccepted(trackNeg))
505             )
506           fHistTPCDedxVsMomNegAntiLambdaCuts->Fill(lInnerMomNeg,lTPCDedxNeg);
507       }
508     }//V0 loop 
509   
510   // Post output data.
511   PostData(0, fHistPtot);
512   PostData(1, fListHist);
513 }      
514
515 //________________________________________________________________________
516 void AliAnalysisTaskESDDedx::Terminate(Option_t *) 
517 {
518   // Draw result to the screen
519   // Called once at the end of the query
520
521   Printf("Reminder for options and selections: fAllConstrainedFlag = %d fMidPseudoRapidityFlag = %d fSelTrackRemoveKink = %d fSelTrackWithOnTheFlyV0 = %d fSelTrackMinClustersTPC = %d fSelTrackMinClustersITS = %d fSelTrackMaxChi2PerClusterTPC = %.2f fSelTrackMaxChi2PerClusterITS = %.2f fSelTrackMaxCov11 = %.2f fSelTrackMaxCov22 = %.2f fSelTrackMaxCov33 = %.2f fSelTrackMaxCov44 = %.2f fSelTrackMaxCov55 = %.2f fSelV0MaxDcaDaughters = %.2f fSelV0MinDecayLength= %.2f",
522          fAllConstrainedFlag,
523          fMidPseudoRapidityFlag,fSelTrackRemoveKink,fSelTrackWithOnTheFlyV0,
524          fSelTrackMinClustersTPC,fSelTrackMinClustersITS,
525          fSelTrackMaxChi2PerClusterTPC,fSelTrackMaxChi2PerClusterITS,
526          fSelTrackMaxCov11,fSelTrackMaxCov22,fSelTrackMaxCov33,fSelTrackMaxCov44,fSelTrackMaxCov55,
527          fSelV0MaxDcaDaughters,fSelV0MinDecayLength);
528
529   fHistPtot = dynamic_cast<TH1F*> (GetOutputData(0));
530   if (!fHistPtot) {
531     Printf("ERROR: fHistPtot not available");
532     return;
533   }
534    
535   TCanvas *cTaskDedx = new TCanvas("AliAnalysisTaskESDDedx","Ptot",10,10,510,510);
536   cTaskDedx->cd(1)->SetLogy();
537   fHistPtot->DrawCopy("E");
538 }
539 //____________________________________________________________________//
540 Bool_t AliAnalysisTaskESDDedx::IsAccepted(AliESDtrack* track) {
541   // Checks if the track is excluded from the cuts
542
543   Int_t   fIdxInt[200];
544   Int_t   nClustersITS = track->GetITSclusters(fIdxInt);
545   Int_t   nClustersTPC = track->GetTPCclusters(fIdxInt);
546
547   Float_t chi2PerClusterITS = -1;
548   Float_t chi2PerClusterTPC = -1;
549   if (nClustersTPC!=0)
550     chi2PerClusterTPC = track->GetTPCchi2()/Float_t(nClustersTPC);
551
552   Double_t extCov[15];
553   track->GetExternalCovariance(extCov);
554
555   if (fSelTrackRemoveKink)
556     if (track->GetKinkIndex(0)>0) return kFALSE;
557   if (fSelTrackMinClustersTPC)
558     if (nClustersTPC < fSelTrackMinClustersTPC) return kFALSE;
559   if (fSelTrackMinClustersITS)
560     if (nClustersITS < fSelTrackMinClustersITS) return kFALSE;
561   if (fSelTrackMaxChi2PerClusterTPC)
562     if (chi2PerClusterTPC > fSelTrackMaxChi2PerClusterTPC) return kFALSE; 
563   if (fSelTrackMaxChi2PerClusterITS)
564     if (chi2PerClusterITS > fSelTrackMaxChi2PerClusterITS) return kFALSE; 
565
566   if (fSelTrackMaxCov11)
567     if (extCov[0]  > fSelTrackMaxCov11) return kFALSE;
568   if (fSelTrackMaxCov22)
569     if (extCov[2]  > fSelTrackMaxCov22) return kFALSE;
570   if (fSelTrackMaxCov33)
571     if (extCov[5]  > fSelTrackMaxCov33) return kFALSE;
572   if (fSelTrackMaxCov44)
573     if (extCov[9]  > fSelTrackMaxCov44) return kFALSE;
574   if(fSelTrackMaxCov55)
575     if (extCov[14] > fSelTrackMaxCov55) return kFALSE;
576   /*
577   if(fMaxSigmaToVertexFlag)
578     if(GetSigmaToVertex(track) > fMaxSigmaToVertex) return kFALSE;
579   if(fITSRefitFlag)
580     if ((track->GetStatus() & AliESDtrack::kITSrefit) == 0) return kFALSE;
581   if(fTPCRefitFlag)
582     if ((track->GetStatus() & AliESDtrack::kTPCrefit) == 0) return kFALSE;
583   if((Pt < fMinPt) || (Pt > fMaxPt)) return kFALSE;
584   */
585   return kTRUE;
586 }