AliPhysics  d497547 (d497547)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliAnalysisTaskPiKpK0Lamba.cxx
Go to the documentation of this file.
2 
3 // ROOT includes
4 #include <TList.h>
5 #include <TFile.h>
6 #include <TMath.h>
7 #include <TH1.h>
8 #include <TH2.h>
9 #include <TProfile.h>
10 #include <TMatrixDSym.h>
11 #include <TF1.h>
12 #include <TRandom.h>
13 #include <TVector3.h>
14 #include <THnSparse.h>
15 #include <TProfile2D.h>
16 #include <TGrid.h>
17 
18 
19 // AliRoot includes
20 #include "AliAnalysisManager.h"
21 #include "AliInputEventHandler.h"
22 #include "AliLog.h"
23 #include "AliAODEvent.h"
24 #include "AliAODVertex.h"
25 #include "AliAODTrack.h"
26 #include "AliAODHeader.h"
27 #include "AliAODVZERO.h"
28 #include "AliVHeader.h"
29 #include "AliVVertex.h"
30 #include "AliVEvent.h"
31 #include "AliVTrack.h"
32 #include "AliESDtrack.h"
33 #include "AliESDEvent.h"
34 #include "AliAODMCParticle.h"
35 #include "AliCentrality.h"
36 #include "AliOADBContainer.h"
37 #include "AliPIDResponse.h"
38 #include "AliPID.h"
39 #include "AliTPCPIDResponse.h"
40 #include "AliAODv0.h"
41 #include "AliMultSelection.h"
42 #include "AliAODcascade.h"
43 #include "AliAODTracklets.h"
44 
45 // STL includes
46 #include <iostream>
47 #include <ctime>
48 #include <sys/time.h>
49 using std::cout;
50 using std::endl;
51 
53  //_____________________________________________________________________________
56  fAOD(0),
57  fPIDResponse(0),
58  fRun(-1),
59  fMultV0(0),
60  fQxnmV0A(0),
61  fQynmV0A(0),
62  fQxnsV0A(0),
63  fQynsV0A(0),
64  fQxnmV0C(0),
65  fQynmV0C(0),
66  fQxnsV0C(0),
67  fQynsV0C(0),
68  fLowCut(0),
69  fHighCut(0),
70  fVtxCut(10.0),
71  fFilterbit(128),
72  fEtaCut(0.8),
73  fNoClus(70),
74  fMinPt(0.2),
75  fMaxPt(20.0),
76  fPileUp(kTRUE),
77  fPileUpTOF(kFALSE),
78  fCent(0),
79  fNHarm(2.),
80  fNsigCut(3.),
81  fQA(kFALSE),
82  fPhiCut(kFALSE),
83  fPhiCutLow(0),
84  fPhiCutHigh(0),
85  fMultTOFLowCut(0),
86  fMultTOFHighCut(0),
87  fMinPiCut(1.),
88  fMaxPiCut(7.),
89  fMinPCut(-25.),
90  fMaxPCut(-14.),
91  fQPos(kFALSE),
92  fQNeg(kFALSE),
93  fExclPID(kFALSE),
94  fNoClusPid(70),
95  fQAV0(kFALSE),
96  fMultCentLowCut(0),
97  fQAOutl(0),
98  fBin1Cent(0),
99  fRemChV0A(0),
100  fEtaRange(2),
101  fRemPhiReg(kFALSE),
102  fCutMultESDdif(15000.),
103  fCrsRowsFrcShCls(kFALSE),
104  flagPsi42A(kTRUE),
105  fNPtBins(17),
106  fNcrFind(0.8),
107  fDCADghtPV(0.1),
108  fMaxDCADght(0.5),
109  fCosPA(0.998),
110  fMinRad(5.),
111  fMaxRad(100.),
112  fArmPodCut(kFALSE),
113  fMinPtDght(kFALSE),
114  fListOfObjects(0),
115  fVtx(0), fVtxBeforeCuts(0), fVtxAfterCuts(0),
116  fMultvsCentBef(0), fMultvsCentAft(0),
117  fCentrBef(0), fCentrAft(0),
118  fCenCL0vsV0MBef(0), fCenCL1vsV0MBef(0), fCenCL0vsCL1Bef(0),
119  fCenCL0vsV0MAft(0), fCenCL1vsV0MAft(0), fCenCL0vsCL1Aft(0),
120  fMultFBvsMultFBTOFBef(0), fMultFBvsMultFBTOFAft(0),
121  fMultESDDifvsMultTPCBef(0), fMultESDDifvsMultTPCAft(0),
122  fSPclsvsSPDtrksBef(0), fSPclsvsSPDtrksAft(0),
123  fMultV0vsMultTPCoutBef(0), fMultV0vsMultTPCoutAft(0),
124  fPidQA(0), fAllQA(0), fV0QA(0), fPidQAB1C(0), fAllQAB1C(0),
125  fQxavsV0Bef(0), fQyavsV0Bef(0), fQxcvsV0Bef(0), fQycvsV0Bef(0),
126  fQxavsVtxZBef(0), fQyavsVtxZBef(0), fQxcvsVtxZBef(0), fQycvsVtxZBef(0),
127  fQxavsV0Aft(0), fQyavsV0Aft(0), fQxcvsV0Aft(0), fQycvsV0Aft(0),
128  fQxavsVtxZAft(0), fQyavsVtxZAft(0), fQxcvsVtxZAft(0), fQycvsVtxZAft(0),
129  fV0AV0Cvn(0), fV0ATPCvn(0), fV0CTPCvn(0),
130  fV0AV0CvnB1C(0), fV0ATPCvnB1C(0), fV0CTPCvnB1C(0),
131  fV0AV0Cvnsq(0), fV0ATPCvnsq(0), fV0CTPCvnsq(0),
132  fV0AV0CvnB1Csq(0), fV0ATPCvnB1Csq(0), fV0CTPCvnB1Csq(0)
133 {
134 
135  for (Int_t j = 0; j < fNPtBins+1; j++)
136  fPtBins[j] = 0;
137 
138  for (Int_t i = 0; i < 90; i++){
139 
140  if (i < 10){
141 
142  fVnAllA[i] = 0;
143  fVnPiA[i] = 0;
144  fVnKA[i] = 0;
145  fVnAntiPA[i] = 0;
146  fVnPihighPtA[i] = 0;
147  fVnPhighPtA[i] = 0;
148 
149  fVnAllC[i] = 0;
150  fVnPiC[i] = 0;
151  fVnKC[i] = 0;
152  fVnAntiPC[i] = 0;
153  fVnPihighPtC[i] = 0;
154  fVnPhighPtC[i] = 0;
155 
156 
157  fPsiA[i] = 0;
158  fPsiC[i] = 0;
159  fPsiAvsPsiC[i] = 0;
160 
161  fSinTrkCosV0A[i] = 0;
162  fCosTrkSinV0A[i] = 0;
163 
164  fSinTrkCosV0C[i] = 0;
165  fCosTrkSinV0C[i] = 0;
166 
167  fSinTrkSinV0A[i] = 0;
168  fCosTrkCosV0A[i] = 0;
169 
170  fSinTrkSinV0C[i] = 0;
171  fCosTrkCosV0C[i] = 0;
172 
173  for (Int_t ii = 0; ii < fNPtBins; ii++){
174 
175  fInvMassK0[ii][i] = 0;
176  fVnK0A[ii][i] = 0;
177  fVnK0C[ii][i] = 0;
178  fInvMassL[ii][i] = 0;
179  fVnLA[ii][i] = 0;
180  fVnLC[ii][i] = 0;
181 
182  if (i == 0){
183  fInvMassK0B1C[ii][i] = 0;
184  fVnK0AB1C[ii][i] = 0;
185  fVnK0CB1C[ii][i] = 0;
186  fInvMassLB1C[ii][i] = 0;
187  fVnLAB1C[ii][i] = 0;
188  fVnLCB1C[ii][i] = 0;
189  }
190 
191  }
192 
193  }
194 
195 
196  fVnAllAB1C[i] = 0;
197  fVnPiAB1C[i] = 0;
198  fVnKAB1C[i] = 0;
199  fVnAntiPAB1C[i] = 0;
200  fVnPihighPtAB1C[i] = 0;
201  fVnPhighPtAB1C[i] = 0;
202 
203  fVnAllCB1C[i] = 0;
204  fVnPiCB1C[i] = 0;
205  fVnKCB1C[i] = 0;
206  fVnAntiPCB1C[i] = 0;
207  fVnPihighPtCB1C[i] = 0;
208  fVnPhighPtCB1C[i] = 0;
209 
210 
211  fPsiAB1C[i] = 0;
212  fPsiCB1C[i] = 0;
213  fPsiAvsPsiCB1C[i] = 0;
214 
215  fSinTrkCosV0AB1C[i] = 0;
216  fCosTrkSinV0AB1C[i] = 0;
217 
218  fSinTrkCosV0CB1C[i] = 0;
219  fCosTrkSinV0CB1C[i] = 0;
220 
221  fSinTrkSinV0AB1C[i] = 0;
222  fCosTrkCosV0AB1C[i] = 0;
223 
224  fSinTrkSinV0CB1C[i] = 0;
225  fCosTrkCosV0CB1C[i] = 0;
226 
227  }
228 
229 }
230 
231 //______________________________________________________________________________
233  AliAnalysisTaskSE(name),
234  fAOD(0),
235  fPIDResponse(0),
236  fRun(-1),
237  fMultV0(0),
238  fQxnmV0A(0),
239  fQynmV0A(0),
240  fQxnsV0A(0),
241  fQynsV0A(0),
242  fQxnmV0C(0),
243  fQynmV0C(0),
244  fQxnsV0C(0),
245  fQynsV0C(0),
246  fLowCut(0),
247  fHighCut(0),
248  fVtxCut(10.0),
249  fFilterbit(128),
250  fEtaCut(0.8),
251  fNoClus(70),
252  fMinPt(0.2),
253  fMaxPt(20.0),
254  fPileUp(kTRUE),
255  fPileUpTOF(kFALSE),
256  fCent(0),
257  fNHarm(2.),
258  fNsigCut(3.),
259  fQA(kFALSE),
260  fPhiCut(kFALSE),
261  fPhiCutLow(0),
262  fPhiCutHigh(0),
263  fMultTOFLowCut(0),
264  fMultTOFHighCut(0),
265  fMinPiCut(1.),
266  fMaxPiCut(7.),
267  fMinPCut(-25.),
268  fMaxPCut(-14.),
269  fQPos(kFALSE),
270  fQNeg(kFALSE),
271  fExclPID(kFALSE),
272  fNoClusPid(70),
273  fQAV0(kFALSE),
274  fMultCentLowCut(0),
275  fQAOutl(0),
276  fBin1Cent(0),
277  fRemChV0A(0),
278  fEtaRange(2),
279  fRemPhiReg(kFALSE),
280  fCutMultESDdif(15000.),
281  fCrsRowsFrcShCls(kFALSE),
282  flagPsi42A(kTRUE),
283  fNPtBins(17),
284  fNcrFind(0.8),
285  fDCADghtPV(0.1),
286  fMaxDCADght(0.5),
287  fCosPA(0.998),
288  fMinRad(5.),
289  fMaxRad(100.),
290  fArmPodCut(kFALSE),
291  fMinPtDght(kFALSE),
292  fListOfObjects(0),
293  fVtx(0), fVtxBeforeCuts(0), fVtxAfterCuts(0),
294  fMultvsCentBef(0), fMultvsCentAft(0),
295  fCentrBef(0), fCentrAft(0),
296  fCenCL0vsV0MBef(0), fCenCL1vsV0MBef(0), fCenCL0vsCL1Bef(0),
297  fCenCL0vsV0MAft(0), fCenCL1vsV0MAft(0), fCenCL0vsCL1Aft(0),
298  fMultFBvsMultFBTOFBef(0), fMultFBvsMultFBTOFAft(0),
299  fMultESDDifvsMultTPCBef(0), fMultESDDifvsMultTPCAft(0),
300  fSPclsvsSPDtrksBef(0), fSPclsvsSPDtrksAft(0),
301  fMultV0vsMultTPCoutBef(0), fMultV0vsMultTPCoutAft(0),
302  fPidQA(0), fAllQA(0), fV0QA(0), fPidQAB1C(0), fAllQAB1C(0),
303  fQxavsV0Bef(0), fQyavsV0Bef(0), fQxcvsV0Bef(0), fQycvsV0Bef(0),
304  fQxavsVtxZBef(0), fQyavsVtxZBef(0), fQxcvsVtxZBef(0), fQycvsVtxZBef(0),
305  fQxavsV0Aft(0), fQyavsV0Aft(0), fQxcvsV0Aft(0), fQycvsV0Aft(0),
306  fQxavsVtxZAft(0), fQyavsVtxZAft(0), fQxcvsVtxZAft(0), fQycvsVtxZAft(0),
307  fV0AV0Cvn(0), fV0ATPCvn(0), fV0CTPCvn(0),
308  fV0AV0CvnB1C(0), fV0ATPCvnB1C(0), fV0CTPCvnB1C(0),
309  fV0AV0Cvnsq(0), fV0ATPCvnsq(0), fV0CTPCvnsq(0),
310  fV0AV0CvnB1Csq(0), fV0ATPCvnB1Csq(0), fV0CTPCvnB1Csq(0)
311 {
312 
313  for (Int_t j = 0; j < fNPtBins+1; j++)
314  fPtBins[j] = 0;
315 
316  for (Int_t i = 0; i < 90; i++){
317 
318  if (i < 10){
319 
320  fVnAllA[i] = 0;
321  fVnPiA[i] = 0;
322  fVnKA[i] = 0;
323  fVnAntiPA[i] = 0;
324  fVnPihighPtA[i] = 0;
325  fVnPhighPtA[i] = 0;
326 
327  fVnAllC[i] = 0;
328  fVnPiC[i] = 0;
329  fVnKC[i] = 0;
330  fVnAntiPC[i] = 0;
331  fVnPihighPtC[i] = 0;
332  fVnPhighPtC[i] = 0;
333 
334 
335  fPsiA[i] = 0;
336  fPsiC[i] = 0;
337  fPsiAvsPsiC[i] = 0;
338 
339  fSinTrkCosV0A[i] = 0;
340  fCosTrkSinV0A[i] = 0;
341 
342  fSinTrkCosV0C[i] = 0;
343  fCosTrkSinV0C[i] = 0;
344 
345  fSinTrkSinV0A[i] = 0;
346  fCosTrkCosV0A[i] = 0;
347 
348  fSinTrkSinV0C[i] = 0;
349  fCosTrkCosV0C[i] = 0;
350 
351  for (Int_t ii = 0; ii < fNPtBins; ii++){
352 
353  fInvMassK0[ii][i] = 0;
354  fVnK0A[ii][i] = 0;
355  fVnK0C[ii][i] = 0;
356  fInvMassL[ii][i] = 0;
357  fVnLA[ii][i] = 0;
358  fVnLC[ii][i] = 0;
359 
360  if (i == 0){
361  fInvMassK0B1C[ii][i] = 0;
362  fVnK0AB1C[ii][i] = 0;
363  fVnK0CB1C[ii][i] = 0;
364  fInvMassLB1C[ii][i] = 0;
365  fVnLAB1C[ii][i] = 0;
366  fVnLCB1C[ii][i] = 0;
367  }
368 
369  }
370 
371  }
372 
373 
374  fVnAllAB1C[i] = 0;
375  fVnPiAB1C[i] = 0;
376  fVnKAB1C[i] = 0;
377  fVnAntiPAB1C[i] = 0;
378  fVnPihighPtAB1C[i] = 0;
379  fVnPhighPtAB1C[i] = 0;
380 
381  fVnAllCB1C[i] = 0;
382  fVnPiCB1C[i] = 0;
383  fVnKCB1C[i] = 0;
384  fVnAntiPCB1C[i] = 0;
385  fVnPihighPtCB1C[i] = 0;
386  fVnPhighPtCB1C[i] = 0;
387 
388 
389  fPsiAB1C[i] = 0;
390  fPsiCB1C[i] = 0;
391  fPsiAvsPsiCB1C[i] = 0;
392 
393  fSinTrkCosV0AB1C[i] = 0;
394  fCosTrkSinV0AB1C[i] = 0;
395 
396  fSinTrkCosV0CB1C[i] = 0;
397  fCosTrkSinV0CB1C[i] = 0;
398 
399  fSinTrkSinV0AB1C[i] = 0;
400  fCosTrkCosV0AB1C[i] = 0;
401 
402  fSinTrkSinV0CB1C[i] = 0;
403  fCosTrkCosV0CB1C[i] = 0;
404 
405  }
406 
407  // Output slot #1 writes into a TTree
408  DefineOutput(1, TList::Class());
409 
410 }
411 
412 //_____________________________________________________________________________
414 {
415  // Destructor
416  if (fListOfObjects)
417  delete fListOfObjects;
418 
419 }
420 
421 //______________________________________________________________________________
423 {
424 
425 
426  fLowCut = new TF1("fLowCut", "[0]+[1]*x - 5.*([2]+[3]*x+[4]*x*x+[5]*x*x*x)", 0, 100);
427  fHighCut = new TF1("fHighCut", "[0]+[1]*x + 5.5*([2]+[3]*x+[4]*x*x+[5]*x*x*x)", 0, 100);
428 
429 
430  //fPhiCutLow = new TF1("fPhiCutLow", "-0.01/x+pi/18.0-0.015", 0, 100);
431  fPhiCutLow = new TF1("fPhiCutLow", "0.1/x/x+pi/18.0-0.025", 0, 100);
432 
433  //fPhiCutHigh = new TF1("fPhiCutHigh", "0.55/x/x+pi/18.0+0.03", 0, 100);
434  fPhiCutHigh = new TF1("fPhiCutHigh", "0.12/x+pi/18.0+0.035", 0, 100);
435 
436 
437  fMultTOFLowCut = new TF1("fMultTOFLowCut", "[0]+[1]*x+[2]*x*x+[3]*x*x*x - 4.*([4]+[5]*x+[6]*x*x+[7]*x*x*x+[8]*x*x*x*x+[9]*x*x*x*x*x)", 0, 10000);
438 
439  fMultTOFHighCut = new TF1("fMultTOFHighCut", "[0]+[1]*x+[2]*x*x+[3]*x*x*x + 4.*([4]+[5]*x+[6]*x*x+[7]*x*x*x+[8]*x*x*x*x+[9]*x*x*x*x*x)", 0, 10000);
440 
441 
442  fMultCentLowCut = new TF1("fMultCentLowCut", "[0]+[1]*x+[2]*exp([3]-[4]*x) - 5.*([5]+[6]*exp([7]-[8]*x))", 0, 100);
443 
444 
445  fLowCut->SetParameters(0.0157497, 0.973488, 0.673612, 0.0290718, -0.000546728, 5.82749e-06);
446  fHighCut->SetParameters(0.0157497, 0.973488, 0.673612, 0.0290718, -0.000546728, 5.82749e-06);
447 
448  fMultTOFLowCut->SetParameters(-1.0178, 0.333132, 9.10282e-05, -1.61861e-08, 1.47848, 0.0385923, -5.06153e-05, 4.37641e-08, -1.69082e-11, 2.35085e-15);
449  fMultTOFHighCut->SetParameters(-1.0178, 0.333132, 9.10282e-05, -1.61861e-08, 1.47848, 0.0385923, -5.06153e-05, 4.37641e-08, -1.69082e-11, 2.35085e-15);
450 
451  fMultCentLowCut->SetParameters(-6.15980e+02, 4.89828e+00, 4.84776e+03, -5.22988e-01, 3.04363e-02, -1.21144e+01, 2.95321e+02, -9.20062e-01, 2.17372e-02);
452 
453 
454 
455 
456  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
457  AliInputEventHandler *inputHandler=dynamic_cast<AliInputEventHandler*>(man->GetInputEventHandler());
458  if (!inputHandler)
459  AliFatal("Input handler needed");
460 
461  //pid response object
462  fPIDResponse=inputHandler->GetPIDResponse();
463  if (!fPIDResponse)
464  AliError("PIDResponse object was not created");
465 
466 
467  OpenFile(1);
468  fListOfObjects = new TList();
469  fListOfObjects->SetOwner();
470 
471 
472  const Int_t nCenB = 10;
473  Float_t cenBins[nCenB+1] = {0, 5., 10., 20., 30., 40., 50., 60., 70., 80., 90.};
474 
475  const Int_t nPtB = 36;
476  Double_t ptBins[nPtB+1] = {0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0, 4.5, 5.0, 5.5, 6.0, 7.0, 8.0, 9.0, 10.0, 12.0, 14.0, 17.0, 20.0, 25.0, 30.0, 40.0, 50.0};
477 
478  const Int_t nPtBL = 20;
479  Double_t ptBinsL[nPtBL+1] = {0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0};
480 
481  const Int_t nPtBH = 15;
482  Double_t ptBinsH[nPtBH+1] = {3.0, 3.25, 3.5, 3.75, 4.0, 4.5, 5.0, 6.0, 7.0, 9.0, 12.0, 16.0, 20.0, 30.0, 40.0, 50.0};
483 
484 
485  if (fQAOutl){
486 
487  fVtx = new TH1I("fVtx","Vtx info (0=no, 1=yes); Vtx; Counts", 2, -0.5, 1.5);
488  fListOfObjects->Add(fVtx);
489 
490  fVtxBeforeCuts = new TH1F("fVtxBeforeCuts", "Vtx distribution (before cuts); Vtx z [cm]; Counts", 120, -30, 30);
492 
493  fVtxAfterCuts = new TH1F("fVtxAfterCuts", "Vtx distribution (after cuts); Vtx z [cm]; Counts", 120, -30, 30);
495 
496 
497  fMultvsCentBef = new TH2F("fMultvsCentBef", "; centrality; multiplicity", 100, 0, 100, 1000, -0.5, 3999.5);
499 
500  fMultvsCentAft = new TH2F("fMultvsCentAft", "; centrality; multiplicity", 100, 0, 100, 1000, -0.5, 3999.5);
502 
503 
504  fCentrBef = new TH1F("fCentrBef", "; centrality; Counts", 100, 0, 100);
506 
507  fCentrAft = new TH1F("fCentrAft", "; centrality; Counts", 100, 0, 100);
509 
510 
511  fCenCL0vsV0MBef = new TH2F("fCenCL0vsV0MBef", "; centrality V0M; centrality CL0", 100, 0, 100, 100, 0, 100);
513 
514  fCenCL1vsV0MBef = new TH2F("fCenCL1vsV0MBef", "; centrality V0M; centrality CL1", 100, 0, 100, 100, 0, 100);
516 
517  fCenCL0vsCL1Bef = new TH2F("fCenCL0vsCL1Bef", "; centrality CL1; centrality CL0", 100, 0, 100, 100, 0, 100);
519 
520 
521  fCenCL0vsV0MAft = new TH2F("fCenCL0vsV0MAft", "; centrality V0M; centrality CL0", 100, 0, 100, 100, 0, 100);
523 
524  fCenCL1vsV0MAft = new TH2F("fCenCL1vsV0MAft", "; centrality V0M; centrality CL1", 100, 0, 100, 100, 0, 100);
526 
527  fCenCL0vsCL1Aft = new TH2F("fCenCL0vsCL1Aft", "; centrality CL1; centrality CL0", 100, 0, 100, 100, 0, 100);
529 
530 
531 
532  fMultFBvsMultFBTOFBef = new TH2I("fMultFBvsMultFBTOFBef", "; multiplicity (FB32); multiplicity (FB32 + TOF)", 1000, -0.5, 3999.5, 1000, -0.5, 1999.5);
534 
535  fMultFBvsMultFBTOFAft = new TH2I("fMultFBvsMultFBTOFAft", "; multiplicity (FB32); multiplicity (FB32 + TOF)", 1000, -0.5, 3999.5, 1000, -0.5, 1999.5);
537 
538 
539  fMultESDDifvsMultTPCBef = new TH2D("fMultESDDifvsMultTPCBef", "; multiplicity (TPC); multiplicity (ESD - FB128*3.38)", 1000, 0, 7000, 1000, -1000, 29000);
541 
542  fMultESDDifvsMultTPCAft = new TH2D("fMultESDDifvsMultTPCAft", "; multiplicity (TPC); multiplicity (ESD - FB128*3.38)", 1000, 0, 7000, 1000, -1000, 29000);
544 
545 
546  fSPclsvsSPDtrksBef = new TH2I("fSPclsvsSPDtrksBef", "; SPD N_{tracklets}; SPD N_{clusters}", 1000, -0.5, 6999.5, 1000, -0.5, 24999.5);
548 
549  fSPclsvsSPDtrksAft = new TH2I("fSPclsvsSPDtrksAft", "; SPD N_{tracklets}; SPD N_{clusters}", 1000, -0.5, 6999.5, 1000, -0.5, 24999.5);
551 
552 
553 
554  fMultV0vsMultTPCoutBef = new TH2F("fMultV0vsMultTPCoutBef", "; TPC out; V0 multiplicity", 1000, 0, 30000, 1000, 0, 40000);
556 
557  fMultV0vsMultTPCoutAft = new TH2F("fMultV0vsMultTPCoutAft", "; TPC out; V0 multiplicity", 1000, 0, 30000, 1000, 0, 40000);
559 
560  }
561 
562 
563  if (fQA){
564 
565  if (!fBin1Cent){
566 
567  Int_t binsPid[6] = { 10, 125, 65, 3, 3, 50};
568  Double_t xminPid[6] = { -0.5, 0, -0.1, -1.5, -0.5, 0};
569  Double_t xmaxPid[6] = { 9.5, 250, 1.2, 1.5, 2.5, 5.};
570 
571 
572  Int_t binsAll[5] = { 10, nPtB, 3, 18, 72};
573  Double_t xminAll[5] = { -0.5, fMinPt, -1.5, -0.9, 0};
574  Double_t xmaxAll[5] = { 9.5, fMaxPt, 1.5, 0.9, 2.*TMath::Pi()};
575 
576 
577  fPidQA = new THnSparseF("fPidQA", "cent:dEdx:beta:q:pidFl:p", 6, binsPid, xminPid, xmaxPid);
578  //fPidQA->Sumw2();
579  fPidQA->GetAxis(0)->SetTitle("centrality");
580  fPidQA->GetAxis(1)->SetTitle("dE/dx");
581  fPidQA->GetAxis(2)->SetTitle("#beta (TOF)");
582  fPidQA->GetAxis(3)->SetTitle("q");
583  fPidQA->GetAxis(4)->SetTitle("pid flag");
584  fPidQA->GetAxis(5)->SetTitle("p (Gev/c");
585  fListOfObjects->Add(fPidQA);
586 
587 
588  fAllQA = new THnSparseF("fAllQA", "cent:pT:q:eta:phi", 5, binsAll, xminAll, xmaxAll);
589  //fAllQA->Sumw2();
590  fAllQA->SetBinEdges(1, ptBins);
591  fAllQA->GetAxis(0)->SetTitle("centrality");
592  fAllQA->GetAxis(1)->SetTitle("p_{T} (Gev/c");
593  fAllQA->GetAxis(2)->SetTitle("q");
594  fAllQA->GetAxis(3)->SetTitle("#eta");
595  fAllQA->GetAxis(4)->SetTitle("#varphi");
596  fListOfObjects->Add(fAllQA);
597 
598 
599 
600  Int_t bins[8] = { 10, fNPtBins, 30, 30, 30, 30, 30, 2};
601  Double_t xmin[8] = { -0.5, fMinPt, 0, 0, 0.98, 0, 0, 0};
602  Double_t xmax[8] = { 9.5, fMaxPt, 3., 3., 1., 0.6, 100., 2};
603 
604  fV0QA = new THnSparseF("fV0QA", "cent:pT:DCATrkPos:DCATrkNeg:cosPA:DCAdght:Rad:V0fl", 8, bins, xmin, xmax);
605  fV0QA->SetBinEdges(1, fPtBins);
606  fV0QA->GetAxis(0)->SetTitle("centrality");
607  fV0QA->GetAxis(1)->SetTitle("p_{T} (Gev/c");
608  fV0QA->GetAxis(2)->SetTitle("DCATrkPosPV");
609  fV0QA->GetAxis(3)->SetTitle("DCATrkNegPV");
610  fV0QA->GetAxis(4)->SetTitle("cosPA");
611  fV0QA->GetAxis(5)->SetTitle("DCAdght");
612  fV0QA->GetAxis(6)->SetTitle("Radius");
613  fV0QA->GetAxis(7)->SetTitle("V0 flag");
614  fListOfObjects->Add(fV0QA);
615 
616  } else {
617 
618  Int_t binsPidB1C[6] = { 90, 125, 65, 3, 3, 50};
619  Double_t xminPidB1C[6] = { 0, 0, -0.1, -1.5, -0.5, 0};
620  Double_t xmaxPidB1C[6] = { 90, 250, 1.2, 1.5, 2.5, 5.};
621 
622 
623  Int_t binsAllB1C[5] = { 90, nPtB, 3, 18, 72};
624  Double_t xminAllB1C[5] = { 0, fMinPt, -1.5, -0.9, 0};
625  Double_t xmaxAllB1C[5] = { 90, fMaxPt, 1.5, 0.9, 2.*TMath::Pi()};
626 
627 
628  fPidQAB1C = new THnSparseF("fPidQAB1C", "cent:dEdx:beta:q:pidFl:p", 6, binsPidB1C, xminPidB1C, xmaxPidB1C);
629  //fPidQA->Sumw2();
630  fPidQAB1C->GetAxis(0)->SetTitle("centrality");
631  fPidQAB1C->GetAxis(1)->SetTitle("dE/dx");
632  fPidQAB1C->GetAxis(2)->SetTitle("#beta (TOF)");
633  fPidQAB1C->GetAxis(3)->SetTitle("q");
634  fPidQAB1C->GetAxis(4)->SetTitle("pid flag");
635  fPidQAB1C->GetAxis(5)->SetTitle("p (Gev/c");
637 
638 
639  fAllQAB1C = new THnSparseF("fAllQAB1C", "cent:pT:q:eta:phi", 5, binsAllB1C, xminAllB1C, xmaxAllB1C);
640  //fAllQA->Sumw2();
641  fAllQAB1C->SetBinEdges(1, ptBins);
642  fAllQAB1C->GetAxis(0)->SetTitle("centrality");
643  fAllQAB1C->GetAxis(1)->SetTitle("p_{T} (Gev/c");
644  fAllQAB1C->GetAxis(2)->SetTitle("q");
645  fAllQAB1C->GetAxis(3)->SetTitle("#eta");
646  fAllQAB1C->GetAxis(4)->SetTitle("#varphi");
648 
649  }
650 
651  }
652 
653  if (fQAV0){
654 
655  fQxavsV0Bef = new TH2D("fQxavsV0Bef", " ; centrality (V0); Q_{x} (V0A)", 100, 0, 100, 1400, -1400., 1400.);
657 
658  fQyavsV0Bef = new TH2D("fQyavsV0Bef", " ; centrality (V0); Q_{y} (V0A)", 100, 0, 100, 1400, -1400., 1400.);
660 
661  fQxcvsV0Bef = new TH2D("fQxcvsV0Bef", " ; centrality (V0); Q_{x} (V0C)", 100, 0, 100, 1400, -1400., 1400.);
663 
664  fQycvsV0Bef = new TH2D("fQycvsV0Bef", " ; centrality (V0); Q_{y} (V0C)", 100, 0, 100, 1400, -1400., 1400.);
666 
667 
668  fQxavsVtxZBef = new TH2D("fQxavsVtxZBef", " ; vertexZ; Q_{x} (V0A)", 20, -10., 10., 1400, -1400., 1400.);
670 
671  fQyavsVtxZBef = new TH2D("fQyavsVtxZBef", " ; vertexZ; Q_{y} (V0A)", 20, -10., 10., 1400, -1400., 1400.);
673 
674  fQxcvsVtxZBef = new TH2D("fQxcvsVtxZBef", " ; vertexZ; Q_{x} (V0C)", 20, -10., 10., 1400, -1400., 1400.);
676 
677  fQycvsVtxZBef = new TH2D("fQycvsVtxZBef", " ; vertexZ; Q_{y} (V0C)", 20, -10., 10., 1400, -1400., 1400.);
679 
680 
681  fQxavsV0Aft = new TH2D("fQxavsV0Aft", " ; centrality (V0); Q_{x} (V0A)", 100, 0, 100, 200, -10., 10.);
683 
684  fQyavsV0Aft = new TH2D("fQyavsV0Aft", " ; centrality (V0); Q_{y} (V0A)", 100, 0, 100, 200, -10., 10.);
686 
687  fQxcvsV0Aft = new TH2D("fQxcvsV0Aft", " ; centrality (V0); Q_{x} (V0C)", 100, 0, 100, 200, -10., 10.);
689 
690  fQycvsV0Aft = new TH2D("fQycvsV0Aft", " ; centrality (V0); Q_{y} (V0C)", 100, 0, 100, 200, -10., 10.);
692 
693 
694  fQxavsVtxZAft = new TH2D("fQxavsVtxZAft", " ; vertexZ; Q_{x} (V0A)", 20, -10., 10., 200, -10., 10);
696 
697  fQyavsVtxZAft = new TH2D("fQyavsVtxZAft", " ; vertexZ; Q_{y} (V0A)", 20, -10., 10., 200, -10., 10);
699 
700  fQxcvsVtxZAft = new TH2D("fQxcvsVtxZAft", " ; vertexZ; Q_{x} (V0C)", 20, -10., 10., 200, -10., 10);
702 
703  fQycvsVtxZAft = new TH2D("fQycvsVtxZAft", " ; vertexZ; Q_{y} (V0C)", 20, -10., 10., 200, -10., 10);
705 
706  }
707 
708 
709  if (!fBin1Cent){
710 
711  fV0AV0Cvn = new TProfile("fV0AV0Cvn", "; centrality percentile; V0A-V0C correlations", nCenB, cenBins);
713 
714  fV0ATPCvn = new TProfile("fV0ATPCvn", "; centrality percentile; V0A-TPC correlations", nCenB, cenBins);
716 
717  fV0CTPCvn = new TProfile("fV0CTPCvn", "; centrality percentile; V0C-TPC correlations", nCenB, cenBins);
719 
720 
721  fV0AV0Cvnsq = new TProfile("fV0AV0Cvnsq", "; centrality percentile; V0A-V0C correlations", nCenB, cenBins);
723 
724  fV0ATPCvnsq = new TProfile("fV0ATPCvnsq", "; centrality percentile; V0A-TPC correlations", nCenB, cenBins);
726 
727  fV0CTPCvnsq = new TProfile("fV0CTPCvnsq", "; centrality percentile; V0C-TPC correlations", nCenB, cenBins);
729 
730 
731 
732  for (Int_t ic = 0; ic < nCenB; ic++){
733 
734  fVnAllA[ic] = new TProfile(Form("fVnAllA_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtB, ptBins);
735  fListOfObjects->Add(fVnAllA[ic]);
736 
737  fVnPiA[ic] = new TProfile(Form("fVnPiA_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
738  fListOfObjects->Add(fVnPiA[ic]);
739 
740  fVnKA[ic] = new TProfile(Form("fVnKA_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
741  fListOfObjects->Add(fVnKA[ic]);
742 
743  fVnAntiPA[ic] = new TProfile(Form("fVnAntiPA_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
744  fListOfObjects->Add(fVnAntiPA[ic]);
745 
746  fVnPihighPtA[ic] = new TProfile(Form("fVnPihighPtA_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBH, ptBinsH);
747  fListOfObjects->Add(fVnPihighPtA[ic]);
748 
749  fVnPhighPtA[ic] = new TProfile(Form("fVnPhighPtA_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBH, ptBinsH);
750  fListOfObjects->Add(fVnPhighPtA[ic]);
751 
752 
753 
754  fVnAllC[ic] = new TProfile(Form("fVnAllC_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtB, ptBins);
755  fListOfObjects->Add(fVnAllC[ic]);
756 
757  fVnPiC[ic] = new TProfile(Form("fVnPiC_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
758  fListOfObjects->Add(fVnPiC[ic]);
759 
760  fVnKC[ic] = new TProfile(Form("fVnKC_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
761  fListOfObjects->Add(fVnKC[ic]);
762 
763  fVnAntiPC[ic] = new TProfile(Form("fVnAntiPC_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
764  fListOfObjects->Add(fVnAntiPC[ic]);
765 
766  fVnPihighPtC[ic] = new TProfile(Form("fVnPihighPtC_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBH, ptBinsH);
767  fListOfObjects->Add(fVnPihighPtC[ic]);
768 
769  fVnPhighPtC[ic] = new TProfile(Form("fVnPhighPtC_%d", ic), "; p_{T} (GeV/c); v_{n}", nPtBH, ptBinsH);
770  fListOfObjects->Add(fVnPhighPtC[ic]);
771 
772 
773  if (fQAV0){
774 
775  fPsiA[ic] = new TH1D(Form("fPsiA_%d", ic), "; #Psi_{n} (V0A); Counts", 80, -2., 2.);
776  fListOfObjects->Add(fPsiA[ic]);
777 
778  fPsiC[ic] = new TH1D(Form("fPsiC_%d", ic), "; #Psi_{n} (V0C); Counts", 80, -2., 2.);
779  fListOfObjects->Add(fPsiC[ic]);
780 
781  fPsiAvsPsiC[ic] = new TH2D(Form("fPsiAvsPsiC_%d", ic), "; #Psi_{n} (V0A); #Psi_{n} (V0C)", 36, -1.8, 1.8, 36, -1.8, 1.8);
782  fListOfObjects->Add(fPsiAvsPsiC[ic]);
783 
784 
785  fSinTrkCosV0A[ic] = new TProfile(Form("fSinTrkCosV0A_%d", ic), "; p_{T} (GeV/c); #LT sin*cos #GT", nPtB, ptBins);
786  fListOfObjects->Add(fSinTrkCosV0A[ic]);
787 
788  fCosTrkSinV0A[ic] = new TProfile(Form("fCosTrkSinV0A_%d", ic), "; p_{T} (GeV/c); #LT cos*sin #GT", nPtB, ptBins);
789  fListOfObjects->Add(fCosTrkSinV0A[ic]);
790 
791 
792  fSinTrkCosV0C[ic] = new TProfile(Form("fSinTrkCosV0C_%d", ic), "; p_{T} (GeV/c); #LT sin*cos #GT", nPtB, ptBins);
793  fListOfObjects->Add(fSinTrkCosV0C[ic]);
794 
795  fCosTrkSinV0C[ic] = new TProfile(Form("fCosTrkSinV0C_%d", ic), "; p_{T} (GeV/c); #LT cos*sin #GT", nPtB, ptBins);
796  fListOfObjects->Add(fCosTrkSinV0C[ic]);
797 
798 
799 
800  fSinTrkSinV0A[ic] = new TProfile(Form("fSinTrkSinV0A_%d", ic), "; p_{T} (GeV/c); #LT sin*sin #GT", nPtB, ptBins);
801  fListOfObjects->Add(fSinTrkSinV0A[ic]);
802 
803  fCosTrkCosV0A[ic] = new TProfile(Form("fCosTrkCosV0A_%d", ic), "; p_{T} (GeV/c); #LT cos*cos #GT", nPtB, ptBins);
804  fListOfObjects->Add(fCosTrkCosV0A[ic]);
805 
806 
807  fSinTrkSinV0C[ic] = new TProfile(Form("fSinTrkSinV0C_%d", ic), "; p_{T} (GeV/c); #LT sin*sin #GT", nPtB, ptBins);
808  fListOfObjects->Add(fSinTrkSinV0C[ic]);
809 
810  fCosTrkCosV0C[ic] = new TProfile(Form("fCosTrkCosV0C_%d", ic), "; p_{T} (GeV/c); #LT cos*cos #GT", nPtB, ptBins);
811  fListOfObjects->Add(fCosTrkCosV0C[ic]);
812 
813  }
814 
815 
816 
817  for (Int_t ib = 0; ib < fNPtBins; ib++){
818 
819  fInvMassK0[ib][ic] = new TH1D(Form("fInvMassK0_%d_%d", ib, ic), "; M_{K^{0}}; Counts", 40, 0.4, 0.6);
820  fListOfObjects->Add(fInvMassK0[ib][ic]);
821 
822  fVnK0A[ib][ic] = new TProfile(Form("fVnK0A_%d_%d", ib, ic), "; M_{K^{0}}; v_{n}", 20, 0.4, 0.6);
823  fListOfObjects->Add(fVnK0A[ib][ic]);
824 
825  fVnK0C[ib][ic] = new TProfile(Form("fVnK0C_%d_%d", ib, ic), "; M_{K^{0}}; v_{n}", 20, 0.4, 0.6);
826  fListOfObjects->Add(fVnK0C[ib][ic]);
827 
828 
829  fInvMassL[ib][ic] = new TH1D(Form("fInvMassL_%d_%d", ib, ic), "; M_{#lambda}; Counts", 40, 1.07, 1.17);
830  fListOfObjects->Add(fInvMassL[ib][ic]);
831 
832  fVnLA[ib][ic] = new TProfile(Form("fVnLA_%d_%d", ib, ic), "; M_{#lambda}; v_{n}", 20, 1.07, 1.17);
833  fListOfObjects->Add(fVnLA[ib][ic]);
834 
835  fVnLC[ib][ic] = new TProfile(Form("fVnLC_%d_%d", ib, ic), "; M_{#lambda}; v_{n}", 20, 1.07, 1.17);
836  fListOfObjects->Add(fVnLC[ib][ic]);
837 
838 
839  if (ic == 0){
840 
841  fInvMassK0B1C[ib][ic] = new TH1D(Form("fInvMassK0B1C_%d_%d", ib, ic), "; M_{K^{0}}; Counts", 40, 0.4, 0.6);
842  fListOfObjects->Add(fInvMassK0B1C[ib][ic]);
843 
844  fVnK0AB1C[ib][ic] = new TProfile(Form("fVnK0AB1C_%d_%d", ib, ic), "; M_{K^{0}}; v_{n}", 20, 0.4, 0.6);
845  fListOfObjects->Add(fVnK0AB1C[ib][ic]);
846 
847  fVnK0CB1C[ib][ic] = new TProfile(Form("fVnK0CB1C_%d_%d", ib, ic), "; M_{K^{0}}; v_{n}", 20, 0.4, 0.6);
848  fListOfObjects->Add(fVnK0CB1C[ib][ic]);
849 
850 
851  fInvMassLB1C[ib][ic] = new TH1D(Form("fInvMassLB1C_%d_%d", ib, ic), "; M_{#lambda}; Counts", 40, 1.07, 1.17);
852  fListOfObjects->Add(fInvMassLB1C[ib][ic]);
853 
854  fVnLAB1C[ib][ic] = new TProfile(Form("fVnLAB1C_%d_%d", ib, ic), "; M_{#lambda}; v_{n}", 20, 1.07, 1.17);
855  fListOfObjects->Add(fVnLAB1C[ib][ic]);
856 
857  fVnLCB1C[ib][ic] = new TProfile(Form("fVnLCB1C_%d_%d", ib, ic), "; M_{#lambda}; v_{n}", 20, 1.07, 1.17);
858  fListOfObjects->Add(fVnLCB1C[ib][ic]);
859 
860  }
861 
862  }
863 
864  }
865 
866  } else {
867 
868  fV0AV0CvnB1C = new TProfile("fV0AV0CvnB1C", "; centrality percentile; V0A-V0C correlations", 90, 0, 90);
870 
871  fV0ATPCvnB1C = new TProfile("fV0ATPCvnB1C", "; centrality percentile; V0A-TPC correlations", 90, 0, 90);
873 
874  fV0CTPCvnB1C = new TProfile("fV0CTPCvnB1C", "; centrality percentile; V0C-TPC correlations", 90, 0, 90);
876 
877 
878  fV0AV0CvnB1Csq = new TProfile("fV0AV0CvnB1Csq", "; centrality percentile; V0A-V0C correlations", 90, 0, 90);
880 
881  fV0ATPCvnB1Csq = new TProfile("fV0ATPCvnB1Csq", "; centrality percentile; V0A-TPC correlations", 90, 0, 90);
883 
884  fV0CTPCvnB1Csq = new TProfile("fV0CTPCvnB1Csq", "; centrality percentile; V0C-TPC correlations", 90, 0, 90);
886 
887 
888  for (Int_t ica = 0; ica < 90; ica++){
889 
890  fVnAllAB1C[ica] = new TProfile(Form("fVnAllAB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtB, ptBins);
891  fListOfObjects->Add(fVnAllAB1C[ica]);
892 
893  fVnPiAB1C[ica] = new TProfile(Form("fVnPiAB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
894  fListOfObjects->Add(fVnPiAB1C[ica]);
895 
896  fVnKAB1C[ica] = new TProfile(Form("fVnKAB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
897  fListOfObjects->Add(fVnKAB1C[ica]);
898 
899  fVnAntiPAB1C[ica] = new TProfile(Form("fVnAntiPAB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
900  fListOfObjects->Add(fVnAntiPAB1C[ica]);
901 
902  fVnPihighPtAB1C[ica] = new TProfile(Form("fVnPihighPtAB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBH, ptBinsH);
903  fListOfObjects->Add(fVnPihighPtAB1C[ica]);
904 
905  fVnPhighPtAB1C[ica] = new TProfile(Form("fVnPhighPtAB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBH, ptBinsH);
906  fListOfObjects->Add(fVnPhighPtAB1C[ica]);
907 
908 
909 
910  fVnAllCB1C[ica] = new TProfile(Form("fVnAllCB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtB, ptBins);
911  fListOfObjects->Add(fVnAllCB1C[ica]);
912 
913  fVnPiCB1C[ica] = new TProfile(Form("fVnPiCB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
914  fListOfObjects->Add(fVnPiCB1C[ica]);
915 
916  fVnKCB1C[ica] = new TProfile(Form("fVnKCB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
917  fListOfObjects->Add(fVnKCB1C[ica]);
918 
919  fVnAntiPCB1C[ica] = new TProfile(Form("fVnAntiPCB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBL, ptBinsL);
920  fListOfObjects->Add(fVnAntiPCB1C[ica]);
921 
922  fVnPihighPtCB1C[ica] = new TProfile(Form("fVnPihighPtCB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBH, ptBinsH);
923  fListOfObjects->Add(fVnPihighPtCB1C[ica]);
924 
925  fVnPhighPtCB1C[ica] = new TProfile(Form("fVnPhighPtCB1C_%d", ica), "; p_{T} (GeV/c); v_{n}", nPtBH, ptBinsH);
926  fListOfObjects->Add(fVnPhighPtCB1C[ica]);
927 
928 
929 
930  if (fQAV0){
931 
932  fPsiAB1C[ica] = new TH1D(Form("fPsiAB1C_%d", ica), "; #Psi_{n} (V0A); Counts", 80, -2., 2.);
933  fListOfObjects->Add(fPsiAB1C[ica]);
934 
935  fPsiCB1C[ica] = new TH1D(Form("fPsiCB1C_%d", ica), "; #Psi_{n} (V0C); Counts", 80, -2., 2.);
936  fListOfObjects->Add(fPsiCB1C[ica]);
937 
938  fPsiAvsPsiCB1C[ica] = new TH2D(Form("fPsiAvsPsiCB1C_%d", ica), "; #Psi_{n} (V0A); #Psi_{n} (V0C)", 36, -1.8, 1.8, 36, -1.8, 1.8);
939  fListOfObjects->Add(fPsiAvsPsiCB1C[ica]);
940 
941 
942  fSinTrkCosV0AB1C[ica] = new TProfile(Form("fSinTrkCosV0AB1C_%d", ica), "; p_{T} (GeV/c); #LT sin*cos #GT", nPtB, ptBins);
943  fListOfObjects->Add(fSinTrkCosV0AB1C[ica]);
944 
945  fCosTrkSinV0AB1C[ica] = new TProfile(Form("fCosTrkSinV0AB1C_%d", ica), "; p_{T} (GeV/c); #LT cos*sin #GT", nPtB, ptBins);
946  fListOfObjects->Add(fCosTrkSinV0AB1C[ica]);
947 
948 
949  fSinTrkCosV0CB1C[ica] = new TProfile(Form("fSinTrkCosV0CB1C_%d", ica), "; p_{T} (GeV/c); #LT sin*cos #GT", nPtB, ptBins);
950  fListOfObjects->Add(fSinTrkCosV0CB1C[ica]);
951 
952  fCosTrkSinV0CB1C[ica] = new TProfile(Form("fCosTrkSinV0CB1C_%d", ica), "; p_{T} (GeV/c); #LT cos*sin #GT", nPtB, ptBins);
953  fListOfObjects->Add(fCosTrkSinV0CB1C[ica]);
954 
955 
956 
957  fSinTrkSinV0AB1C[ica] = new TProfile(Form("fSinTrkSinV0AB1C_%d", ica), "; p_{T} (GeV/c); #LT sin*sin #GT", nPtB, ptBins);
958  fListOfObjects->Add(fSinTrkSinV0AB1C[ica]);
959 
960  fCosTrkCosV0AB1C[ica] = new TProfile(Form("fCosTrkCosV0AB1C_%d", ica), "; p_{T} (GeV/c); #LT cos*cos #GT", nPtB, ptBins);
961  fListOfObjects->Add(fCosTrkCosV0AB1C[ica]);
962 
963 
964  fSinTrkSinV0CB1C[ica] = new TProfile(Form("fSinTrkSinV0CB1C_%d", ica), "; p_{T} (GeV/c); #LT sin*sin #GT", nPtB, ptBins);
965  fListOfObjects->Add(fSinTrkSinV0CB1C[ica]);
966 
967  fCosTrkCosV0CB1C[ica] = new TProfile(Form("fCosTrkCosV0CB1C_%d", ica), "; p_{T} (GeV/c); #LT cos*cos #GT", nPtB, ptBins);
968  fListOfObjects->Add(fCosTrkCosV0CB1C[ica]);
969 
970  }
971 
972  }
973 
974  }
975 
976  // Post output data.
977  PostData(1, fListOfObjects);
978 }
979 
980 //______________________________________________________________________________
982 {
983  // Main loop
984  // Called for each event
985  fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
986  if(!fAOD || !fAOD->GetHeader()){
987  Printf("%s:%d AODEvent not found in Input Manager",(char*)__FILE__,__LINE__);
988  this->Dump();
989  return;
990  }
991 
992 
993  Int_t run = fAOD->GetRunNumber();
994  if(run != fRun){
995  // Load the calibrations run dependent
996  OpenInfoCalbration(run);
997  fRun = run;
998  }
999 
1000 
1001  Float_t zvtx = GetVertex(fAOD);
1002 
1003  if(zvtx< -990){
1004 
1005  if (fQAOutl)
1006  fVtx->Fill(0);
1007 
1008  } else {
1009 
1010  if (fQAOutl){
1011  fVtx->Fill(1);
1012  fVtxBeforeCuts->Fill(zvtx);
1013  }
1014 
1015  if (TMath::Abs(zvtx) < fVtxCut)
1016  Analyze(fAOD, zvtx);
1017 
1018  }
1019 
1020  // Post output data.
1021  PostData(1, fListOfObjects);
1022 }
1023 
1024 //________________________________________________________________________
1026 {
1027 
1028  //Centrality
1029  Float_t v0Centr = -100.;
1030  Float_t cl1Centr = -100.;
1031  Float_t cl0Centr = -100.;
1032 
1033  AliMultSelection* MultSelection = 0x0;
1034  MultSelection = (AliMultSelection*) aod->FindListObject("MultSelection");
1035  if( !MultSelection) {
1036  AliWarning("AliMultSelection object not found!");
1037  return;
1038  } else {
1039  v0Centr = MultSelection->GetMultiplicityPercentile("V0M");
1040  cl1Centr = MultSelection->GetMultiplicityPercentile("CL1");
1041  cl0Centr = MultSelection->GetMultiplicityPercentile("CL0");
1042  }
1043 
1044  if (v0Centr >= 90. || v0Centr < 0)
1045  return;
1046 
1047 
1048  Int_t nITSClsLy0 = aod->GetNumberOfITSClusters(0);
1049  Int_t nITSClsLy1 = aod->GetNumberOfITSClusters(1);
1050  Int_t nITSCls = nITSClsLy0 + nITSClsLy1;
1051 
1052  AliAODTracklets* aodTrkl = (AliAODTracklets*)aod->GetTracklets();
1053  Int_t nITSTrkls = aodTrkl->GetNumberOfTracklets();
1054 
1055  //cout<<nITSClsLy0<<" "<<nITSClsLy1<<" "<<nITSCls<<" "<<nITSTrkls<<endl;
1056 
1057 
1058  const Int_t nTracks = aod->GetNumberOfTracks();
1059  Int_t multEsd = ((AliAODHeader*)aod->GetHeader())->GetNumberOfESDTracks();
1060 
1061  Int_t multTrk = 0;
1062  Int_t multTrkBefC = 0;
1063  Int_t multTrkTOFBefC = 0;
1064  Int_t multTPC = 0;
1065  Int_t multTPCout = 0;
1066 
1067  for (Int_t it = 0; it < nTracks; it++) {
1068 
1069  AliAODTrack* aodTrk = (AliAODTrack*)aod->GetTrack(it);
1070 
1071  if (!aodTrk){
1072  delete aodTrk;
1073  continue;
1074  }
1075 
1076  if (aodTrk->GetFlags()&AliESDtrack::kTPCout)
1077  multTPCout++;
1078 
1079  if (aodTrk->TestFilterBit(32)){
1080 
1081  multTrkBefC++;
1082 
1083  if ( TMath::Abs(aodTrk->GetTOFsignalDz()) <= 10. && aodTrk->GetTOFsignal() >= 12000. && aodTrk->GetTOFsignal() <= 25000.)
1084  multTrkTOFBefC++;
1085 
1086  if ((TMath::Abs(aodTrk->Eta()) < fEtaCut) && (aodTrk->GetTPCNcls() >= fNoClus) && (aodTrk->Pt() >= fMinPt) && (aodTrk->Pt() < fMaxPt))
1087  multTrk++;
1088 
1089  }
1090 
1091  if (aodTrk->TestFilterBit(128))
1092  multTPC++;
1093 
1094  }
1095 
1096 
1097  Float_t multTPCn = multTPC;
1098  Float_t multEsdn = multEsd;
1099  Float_t multESDTPCDif = multEsdn - multTPCn*3.38;
1100 
1101  AliAODVZERO* aodV0 = aod->GetVZEROData();
1102  Float_t multV0a = aodV0->GetMTotV0A();
1103  Float_t multV0c = aodV0->GetMTotV0C();
1104  Float_t multV0Tot = multV0a + multV0c;
1105 
1106 
1107  if (fQAOutl){
1108 
1109  fCentrBef->Fill(v0Centr);
1110 
1111  fMultFBvsMultFBTOFBef->Fill(multTrkBefC, multTrkTOFBefC);
1112  fMultESDDifvsMultTPCBef->Fill(multTPCn, multESDTPCDif);
1113 
1114  fMultvsCentBef->Fill(v0Centr, multTrk);
1115 
1116  fCenCL0vsV0MBef->Fill(v0Centr, cl0Centr);
1117  fCenCL1vsV0MBef->Fill(v0Centr, cl1Centr);
1118  fCenCL0vsCL1Bef->Fill(cl1Centr, cl0Centr);
1119 
1120  fSPclsvsSPDtrksBef->Fill(nITSTrkls, nITSCls);
1121 
1122  fMultV0vsMultTPCoutBef->Fill(multTPCout, multV0Tot);
1123 
1124  }
1125 
1126 
1127  //new vertex selection
1128  const AliAODVertex* vtTrc = aod->GetPrimaryVertex();
1129  const AliAODVertex* vtSPD = aod->GetPrimaryVertexSPD();
1130 
1131  if (vtTrc->GetNContributors() < 2 || vtSPD->GetNContributors()<1)
1132  return; // one of vertices is missing
1133 
1134  double covTrc[6], covSPD[6];
1135  vtTrc->GetCovarianceMatrix(covTrc);
1136  vtSPD->GetCovarianceMatrix(covSPD);
1137 
1138  double dz = vtTrc->GetZ() - vtSPD->GetZ();
1139 
1140  double errTot = TMath::Sqrt(covTrc[5]+covSPD[5]);
1141  double errTrc = TMath::Sqrt(covTrc[5]);
1142  double nsigTot = dz/errTot;
1143  double nsigTrc = dz/errTrc;
1144 
1145  if (TMath::Abs(dz)>0.2 || TMath::Abs(nsigTot)>10 || TMath::Abs(nsigTrc)>20)
1146  return; // bad vertexing
1147 
1148 
1149  // vertex cut from old selection
1150  TString vtxTyp = vtSPD->GetTitle();
1151  Double_t zRes = TMath::Sqrt(covSPD[5]);
1152  if ((vtxTyp.Contains("vertexer:Z")) && (zRes>0.25) && (vtSPD->GetNContributors() < 20))
1153  return;
1154 
1155 
1156 
1157 
1158  //pileup cuts
1159  if (fPileUp){
1160 
1161  if (cl0Centr < fLowCut->Eval(v0Centr))
1162  return;
1163 
1164  if (cl0Centr > fHighCut->Eval(v0Centr))
1165  return;
1166 
1167 
1168  if (multESDTPCDif > fCutMultESDdif)
1169  return;
1170 
1171  if (Float_t(multTrkTOFBefC) < fMultTOFLowCut->Eval(Float_t(multTrkBefC)))
1172  return;
1173 
1174  if (Float_t(multTrkTOFBefC) > fMultTOFHighCut->Eval(Float_t(multTrkBefC)))
1175  return;
1176 
1177  if (plpMV(aod))
1178  return;
1179 
1180  Short_t isPileup = aod->IsPileupFromSPD(3);
1181  if (isPileup != 0)
1182  return;
1183 
1184  if (((AliAODHeader*)aod->GetHeader())->GetRefMultiplicityComb08() < 0)
1185  return;
1186 
1187  //new function for 2015 to remove incomplete events
1188  if (aod->IsIncompleteDAQ())
1189  return;
1190 
1191 
1192  //new cut to remove outliers
1193  if (Float_t(multTrk) < fMultCentLowCut->Eval(v0Centr))
1194  return;
1195 
1196  }
1197 
1198 
1199 
1200  if (fCent == 1)
1201  v0Centr = cl0Centr;
1202  else if (fCent == 2)
1203  v0Centr = cl1Centr;
1204 
1205 
1206  Short_t centrCode = -10;
1207  if ((v0Centr >= 0) && (v0Centr < 5.))
1208  centrCode = 0;
1209  else if ((v0Centr >= 5.) && (v0Centr < 10.))
1210  centrCode = 1;
1211  else if ((v0Centr >= 10.) && (v0Centr < 20.))
1212  centrCode = 2;
1213  else if ((v0Centr >= 20.) && (v0Centr < 30.))
1214  centrCode = 3;
1215  else if ((v0Centr >= 30.) && (v0Centr < 40.))
1216  centrCode = 4;
1217  else if ((v0Centr >= 40.) && (v0Centr < 50.))
1218  centrCode = 5;
1219  else if ((v0Centr >= 50.) && (v0Centr < 60.))
1220  centrCode = 6;
1221  else if ((v0Centr >= 60.) && (v0Centr < 70.))
1222  centrCode = 7;
1223  else if ((v0Centr >= 70.) && (v0Centr < 80.))
1224  centrCode = 8;
1225  else if ((v0Centr >= 80.) && (v0Centr < 90.))
1226  centrCode = 9;
1227 
1228  if (centrCode < 0)
1229  return;
1230 
1231 
1232  Int_t iCentV0 = Int_t(v0Centr);
1233  if (iCentV0 >= 90)
1234  return;
1235 
1236 
1237  Int_t iCentSPD = Int_t(cl1Centr);
1238  if (iCentSPD >= 90)
1239  return;
1240 
1241 
1242 
1243  //V0 info
1244  Double_t Qxan = 0, Qyan = 0;
1245  Double_t Qxcn = 0, Qycn = 0;
1246  Double_t sumMa = 0, sumMc = 0;
1247 
1248 
1249 
1250  for (Int_t iV0 = 0; iV0 < 64; iV0++) {
1251 
1252  if (fRemChV0A){
1253 
1254  if (iV0 == 46)
1255  continue;
1256 
1257  }
1258 
1259 
1260  Double_t phiV0 = TMath::PiOver4()*(0.5 + iV0 % 8);
1261  Float_t multv0 = aodV0->GetMultiplicity(iV0);
1262 
1263  if (iV0 < 32){
1264 
1265  Double_t multCorC = -10;
1266 
1267  if (iV0 < 8)
1268  multCorC = multv0/fMultV0->GetBinContent(iV0+1)*fMultV0->GetBinContent(1);
1269  else if (iV0 >= 8 && iV0 < 16)
1270  multCorC = multv0/fMultV0->GetBinContent(iV0+1)*fMultV0->GetBinContent(9);
1271  else if (iV0 >= 16 && iV0 < 24)
1272  multCorC = multv0/fMultV0->GetBinContent(iV0+1)*fMultV0->GetBinContent(17);
1273  else if (iV0 >= 24 && iV0 < 32)
1274  multCorC = multv0/fMultV0->GetBinContent(iV0+1)*fMultV0->GetBinContent(25);
1275 
1276  if (multCorC < 0){
1277  cout<<"Problem with multiplicity in V0C"<<endl;
1278  continue;
1279  }
1280 
1281  Qxcn += TMath::Cos(fNHarm*phiV0) * multCorC;
1282  Qycn += TMath::Sin(fNHarm*phiV0) * multCorC;
1283 
1284  sumMc = sumMc + multCorC;
1285 
1286  } else {
1287 
1288  Double_t multCorA = -10;
1289 
1290  if (iV0 >= 32 && iV0 < 40)
1291  multCorA = multv0/fMultV0->GetBinContent(iV0+1)*fMultV0->GetBinContent(33);
1292  else if (iV0 >= 40 && iV0 < 48)
1293  multCorA = multv0/fMultV0->GetBinContent(iV0+1)*fMultV0->GetBinContent(41);
1294  else if (iV0 >= 48 && iV0 < 56)
1295  multCorA = multv0/fMultV0->GetBinContent(iV0+1)*fMultV0->GetBinContent(49);
1296  else if (iV0 >= 56 && iV0 < 64)
1297  multCorA = multv0/fMultV0->GetBinContent(iV0+1)*fMultV0->GetBinContent(57);
1298 
1299  if (multCorA < 0){
1300  cout<<"Problem with multiplicity in V0A"<<endl;
1301  continue;
1302  }
1303 
1304  Qxan += TMath::Cos(fNHarm*phiV0) * multCorA;
1305  Qyan += TMath::Sin(fNHarm*phiV0) * multCorA;
1306 
1307  sumMa = sumMa + multCorA;
1308 
1309  }
1310 
1311  }
1312 
1313  if (sumMa < 0 || sumMc < 0)
1314  return;
1315 
1316 
1317  Double_t QxanCor = Qxan;
1318  Double_t QyanCor = (Qyan - fQynmV0A->GetBinContent(iCentSPD+1))/fQynsV0A->GetBinContent(iCentSPD+1);
1319  Double_t QxcnCor = Qxcn;
1320  Double_t QycnCor = (Qycn - fQynmV0C->GetBinContent(iCentSPD+1))/fQynsV0C->GetBinContent(iCentSPD+1);
1321 
1322  if (fNHarm != 4.){
1323  QxanCor = (Qxan - fQxnmV0A->GetBinContent(iCentSPD+1))/fQxnsV0A->GetBinContent(iCentSPD+1);
1324  QxcnCor = (Qxcn - fQxnmV0C->GetBinContent(iCentSPD+1))/fQxnsV0C->GetBinContent(iCentSPD+1);
1325  }
1326 
1327 
1328 
1329 
1330  if (fQAOutl){
1331 
1332  fVtxAfterCuts->Fill(vtxZ);
1333  fCentrAft->Fill(v0Centr);
1334 
1335  fMultFBvsMultFBTOFAft->Fill(multTrkBefC, multTrkTOFBefC);
1336  fMultESDDifvsMultTPCAft->Fill(multTPCn, multESDTPCDif);
1337 
1338  fMultvsCentAft->Fill(v0Centr, multTrk);
1339 
1340  fCenCL0vsV0MAft->Fill(v0Centr, cl0Centr);
1341  fCenCL1vsV0MAft->Fill(v0Centr, cl1Centr);
1342  fCenCL0vsCL1Aft->Fill(cl1Centr, cl0Centr);
1343 
1344  fSPclsvsSPDtrksAft->Fill(nITSTrkls, nITSCls);
1345 
1346  fMultV0vsMultTPCoutAft->Fill(multTPCout, multV0Tot);
1347  }
1348 
1349 
1350  Double_t psina = TMath::ATan2(QyanCor, QxanCor)/fNHarm;
1351  Double_t psinc = TMath::ATan2(QycnCor, QxcnCor)/fNHarm;
1352 
1353  if (fQAV0){
1354 
1355  if (!fBin1Cent){
1356  fPsiA[centrCode]->Fill(psina);
1357  fPsiC[centrCode]->Fill(psinc);
1358  fPsiAvsPsiC[centrCode]->Fill(psina, psinc);
1359  } else {
1360  fPsiAB1C[iCentV0]->Fill(psina);
1361  fPsiCB1C[iCentV0]->Fill(psinc);
1362  fPsiAvsPsiCB1C[iCentV0]->Fill(psina, psinc);
1363  }
1364 
1365  fQxavsV0Bef->Fill(v0Centr, Qxan);
1366  fQyavsV0Bef->Fill(v0Centr, Qyan);
1367  fQxcvsV0Bef->Fill(v0Centr, Qxcn);
1368  fQycvsV0Bef->Fill(v0Centr, Qycn);
1369 
1370  fQxavsVtxZBef->Fill(vtxZ, Qxan);
1371  fQyavsVtxZBef->Fill(vtxZ, Qyan);
1372  fQxcvsVtxZBef->Fill(vtxZ, Qxcn);
1373  fQycvsVtxZBef->Fill(vtxZ, Qycn);
1374 
1375  fQxavsV0Aft->Fill(v0Centr, QxanCor);
1376  fQyavsV0Aft->Fill(v0Centr, QyanCor);
1377  fQxcvsV0Aft->Fill(v0Centr, QxcnCor);
1378  fQycvsV0Aft->Fill(v0Centr, QycnCor);
1379 
1380  fQxavsVtxZAft->Fill(vtxZ, QxanCor);
1381  fQyavsVtxZAft->Fill(vtxZ, QyanCor);
1382  fQxcvsVtxZAft->Fill(vtxZ, QxcnCor);
1383  fQycvsVtxZAft->Fill(vtxZ, QycnCor);
1384 
1385  }
1386 
1387 
1388 
1389  Double_t Qxtn = 0, Qytn = 0;
1390  Int_t sumMt = 0;
1391 
1392  for (Int_t it1 = 0; it1 < nTracks; it1++) {
1393 
1394  AliAODTrack* aodTrk1 = (AliAODTrack*)aod->GetTrack(it1);
1395 
1396  if (!aodTrk1){
1397  delete aodTrk1;
1398  continue;
1399  }
1400 
1401  if (aodTrk1->TestFilterBit(768) && TMath::Abs(aodTrk1->Eta()) < fEtaCut && aodTrk1->GetTPCNcls() >= 70 && aodTrk1->Pt() >= fMinPt && aodTrk1->Pt() < 5.){
1402 
1403  Qxtn += TMath::Cos(fNHarm*aodTrk1->Phi());
1404  Qytn += TMath::Sin(fNHarm*aodTrk1->Phi());
1405  sumMt++;
1406 
1407  }
1408 
1409 
1410  if (!(aodTrk1->TestFilterBit(fFilterbit)))
1411  continue;
1412 
1413  if ((TMath::Abs(aodTrk1->Eta()) >= fEtaCut) || (aodTrk1->GetTPCNcls() < fNoClus) || (aodTrk1->Pt() < fMinPt) || (aodTrk1->Pt() >= fMaxPt))
1414  continue;
1415 
1416 
1417  if (fPhiCut){
1418  Double_t phimod = aodTrk1->Phi();
1419  if(aod->GetMagneticField() < 0) // for negative polarity field
1420  phimod = TMath::TwoPi() - phimod;
1421  if(aodTrk1->Charge() < 0) // for negative charge
1422  phimod = TMath::TwoPi() - phimod;
1423  if(phimod < 0)
1424  cout << "Warning!!!!! phi < 0: " << phimod << endl;
1425 
1426  phimod += TMath::Pi()/18.0; // to center gap in the middle
1427  phimod = fmod(phimod, TMath::Pi()/9.0);
1428  if(phimod < fPhiCutHigh->Eval(aodTrk1->Pt()) && phimod > fPhiCutLow->Eval(aodTrk1->Pt()))
1429  continue; // reject track
1430  }
1431 
1432 
1433  if (fRemPhiReg){
1434  if (aodTrk1->Phi() > 1.7 && aodTrk1->Phi() < 2.7)
1435  continue;
1436  }
1437 
1438 
1439  if (fPileUpTOF){
1440  if(TMath::Abs(aodTrk1->GetTOFsignalDz())>10.)
1441  continue;
1442  if(aodTrk1->GetTOFsignal() < 12000.)
1443  continue;
1444  if(aodTrk1->GetTOFsignal() > 25000.)
1445  continue;
1446  }
1447 
1448 
1449  if (fQPos){
1450  if (aodTrk1->Charge() < 0)
1451  continue;
1452  }
1453 
1454 
1455  if (fQNeg){
1456  if (aodTrk1->Charge() > 0)
1457  continue;
1458  }
1459 
1460 
1461  if (fEtaRange == 0){
1462  if (aodTrk1->Eta() >= 0)
1463  continue;
1464  }
1465 
1466  if (fEtaRange == 1){
1467  if (aodTrk1->Eta() < 0)
1468  continue;
1469  }
1470 
1471 
1472  if (fCrsRowsFrcShCls){
1473 
1474  Float_t nrowscr = aodTrk1->GetTPCNCrossedRows();
1475 
1476  Float_t clsFind = aodTrk1->GetTPCNclsF();
1477  if (clsFind <= 0)
1478  continue;
1479 
1480  Float_t ratCrRowsClsFind = nrowscr/clsFind;
1481 
1482  if (nrowscr < 120)
1483  continue;
1484 
1485  if (ratCrRowsClsFind < 0.9)
1486  continue;
1487 
1488  }
1489 
1490 
1491  Double_t vnSPV0A = TMath::Cos(fNHarm*aodTrk1->Phi())*QxanCor + TMath::Sin(fNHarm*aodTrk1->Phi())*QyanCor;
1492  Double_t vnSPV0C = TMath::Cos(fNHarm*aodTrk1->Phi())*QxcnCor + TMath::Sin(fNHarm*aodTrk1->Phi())*QycnCor;
1493 
1494 
1495  if (fNHarm == 2. && flagPsi42A){
1496  vnSPV0A = TMath::Cos(4.*aodTrk1->Phi())*(QxanCor*QxanCor - QyanCor*QyanCor) + TMath::Sin(4.*aodTrk1->Phi())*2.*QxanCor*QyanCor;
1497  vnSPV0C = TMath::Cos(4.*aodTrk1->Phi())*(QxcnCor*QxcnCor - QycnCor*QycnCor) + TMath::Sin(4.*aodTrk1->Phi())*2.*QxcnCor*QycnCor;
1498  }
1499 
1500 
1501  if (!fBin1Cent){
1502 
1503  fVnAllA[centrCode]->Fill(aodTrk1->Pt(), vnSPV0A);
1504  fVnAllC[centrCode]->Fill(aodTrk1->Pt(), vnSPV0C);
1505 
1506  } else {
1507 
1508  fVnAllAB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0A);
1509  fVnAllCB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0C);
1510 
1511  }
1512 
1513 
1514  if (fQAV0){
1515 
1516  Double_t sinTRKcosV0A = TMath::Sin(fNHarm*aodTrk1->Phi())*QxanCor;
1517  Double_t cosTRKsinV0A = TMath::Cos(fNHarm*aodTrk1->Phi())*QyanCor;
1518 
1519  Double_t sinTRKcosV0C = TMath::Sin(fNHarm*aodTrk1->Phi())*QxcnCor;
1520  Double_t cosTRKsinV0C = TMath::Cos(fNHarm*aodTrk1->Phi())*QycnCor;
1521 
1522  Double_t sinTRKsinV0A = TMath::Sin(fNHarm*aodTrk1->Phi())*QyanCor;
1523  Double_t cosTRKcosV0A = TMath::Cos(fNHarm*aodTrk1->Phi())*QxanCor;
1524 
1525  Double_t sinTRKsinV0C = TMath::Sin(fNHarm*aodTrk1->Phi())*QycnCor;
1526  Double_t cosTRKcosV0C = TMath::Cos(fNHarm*aodTrk1->Phi())*QxcnCor;
1527 
1528  if (!fBin1Cent){
1529 
1530  fSinTrkCosV0A[centrCode]->Fill(aodTrk1->Pt(), sinTRKcosV0A);
1531  fCosTrkSinV0A[centrCode]->Fill(aodTrk1->Pt(), cosTRKsinV0A);
1532 
1533  fSinTrkCosV0C[centrCode]->Fill(aodTrk1->Pt(), sinTRKcosV0C);
1534  fCosTrkSinV0C[centrCode]->Fill(aodTrk1->Pt(), cosTRKsinV0C);
1535 
1536  fSinTrkSinV0A[centrCode]->Fill(aodTrk1->Pt(), sinTRKsinV0A);
1537  fCosTrkCosV0A[centrCode]->Fill(aodTrk1->Pt(), cosTRKcosV0A);
1538 
1539  fSinTrkSinV0C[centrCode]->Fill(aodTrk1->Pt(), sinTRKsinV0C);
1540  fCosTrkCosV0C[centrCode]->Fill(aodTrk1->Pt(), cosTRKcosV0C);
1541 
1542  } else {
1543 
1544  fSinTrkCosV0AB1C[iCentV0]->Fill(aodTrk1->Pt(), sinTRKcosV0A);
1545  fCosTrkSinV0AB1C[iCentV0]->Fill(aodTrk1->Pt(), cosTRKsinV0A);
1546 
1547  fSinTrkCosV0CB1C[iCentV0]->Fill(aodTrk1->Pt(), sinTRKcosV0C);
1548  fCosTrkSinV0CB1C[iCentV0]->Fill(aodTrk1->Pt(), cosTRKsinV0C);
1549 
1550  fSinTrkSinV0AB1C[iCentV0]->Fill(aodTrk1->Pt(), sinTRKsinV0A);
1551  fCosTrkCosV0AB1C[iCentV0]->Fill(aodTrk1->Pt(), cosTRKcosV0A);
1552 
1553  fSinTrkSinV0CB1C[iCentV0]->Fill(aodTrk1->Pt(), sinTRKsinV0C);
1554  fCosTrkCosV0CB1C[iCentV0]->Fill(aodTrk1->Pt(), cosTRKcosV0C);
1555 
1556  }
1557 
1558  }
1559 
1560  if (fQA){
1561 
1562  if (!fBin1Cent){
1563 
1564  Double_t allQA[5] = {Double_t(centrCode),
1565  aodTrk1->Pt(),
1566  Double_t(aodTrk1->Charge()),
1567  aodTrk1->Eta(),
1568  aodTrk1->Phi()};
1569  fAllQA->Fill(allQA);
1570 
1571  } else {
1572 
1573  Double_t allQAB1C[5] = {Double_t(iCentV0),
1574  aodTrk1->Pt(),
1575  Double_t(aodTrk1->Charge()),
1576  aodTrk1->Eta(),
1577  aodTrk1->Phi()};
1578  fAllQAB1C->Fill(allQAB1C);
1579  }
1580 
1581  }
1582 
1583 
1584 
1585  if (aodTrk1->GetTPCsignalN() < fNoClusPid)
1586  continue;
1587 
1588 
1589  Double_t piDEDX = fPIDResponse->GetTPCResponse().GetExpectedSignal(aodTrk1, AliPID::kPion, AliTPCPIDResponse::kdEdxDefault, kTRUE);
1590  Double_t Dpi = aodTrk1->GetTPCsignal() - piDEDX;
1591 
1592 
1593  //pi high pT
1594  if ((Dpi > fMinPiCut) && (Dpi < fMaxPiCut) && (aodTrk1->Pt() >= 3.) && (aodTrk1->GetTPCmomentum() > 3.)){
1595 
1596  Double_t rapPiHPt = GetRapidity(0.139570, aodTrk1->Pt(), aodTrk1->Eta());
1597 
1598  if (TMath::Abs(rapPiHPt) < 0.5){
1599 
1600  if (!fBin1Cent){
1601  fVnPihighPtA[centrCode]->Fill(aodTrk1->Pt(), vnSPV0A);
1602  fVnPihighPtC[centrCode]->Fill(aodTrk1->Pt(), vnSPV0C);
1603 
1604  } else {
1605  fVnPihighPtAB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0A);
1606  fVnPihighPtCB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0C);
1607  }
1608 
1609  }
1610 
1611  }
1612 
1613  //p high pT
1614  if ((Dpi > fMinPCut) && (Dpi < fMaxPCut) && (aodTrk1->Pt() >= 3.) && (aodTrk1->GetTPCmomentum() > 3.)){
1615 
1616  Double_t rapPHPt = GetRapidity(0.938272, aodTrk1->Pt(), aodTrk1->Eta());
1617 
1618  if (TMath::Abs(rapPHPt) < 0.5){
1619 
1620  if (!fBin1Cent){
1621  fVnPhighPtA[centrCode]->Fill(aodTrk1->Pt(), vnSPV0A);
1622  fVnPhighPtC[centrCode]->Fill(aodTrk1->Pt(), vnSPV0C);
1623 
1624  } else {
1625  fVnPhighPtAB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0A);
1626  fVnPhighPtCB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0C);
1627  }
1628 
1629  }
1630 
1631  }
1632 
1633 
1634 
1635  Double_t nSigPiTPC = fPIDResponse->NumberOfSigmasTPC(aodTrk1, AliPID::kPion);
1636  Double_t nSigKTPC = fPIDResponse->NumberOfSigmasTPC(aodTrk1, AliPID::kKaon);
1637  Double_t nSigPTPC = fPIDResponse->NumberOfSigmasTPC(aodTrk1, AliPID::kProton);
1638 
1639  Double_t nSigPiTOF = fPIDResponse->NumberOfSigmasTOF(aodTrk1, AliPID::kPion);
1640  Double_t nSigKTOF = fPIDResponse->NumberOfSigmasTOF(aodTrk1, AliPID::kKaon);
1641  Double_t nSigPTOF = fPIDResponse->NumberOfSigmasTOF(aodTrk1, AliPID::kProton);
1642 
1643  Double_t nSigmaPi = 99999.;
1644  Double_t nSigmaK = 99999.;
1645  Double_t nSigmaP = 99999.;
1646 
1647  Float_t intL = aodTrk1->GetIntegratedLength();
1648  Float_t timeTOF = aodTrk1->GetTOFsignal();
1649  Double_t betaPiK = -0.05;
1650  Double_t betaP = -0.05;
1651 
1652  //pi+K
1653  if ((aodTrk1->Pt() >= 0.4) && (aodTrk1->GetFlags()&AliESDtrack::kTOFout) && (aodTrk1->GetFlags()&AliESDtrack::kTIME) && (!(aodTrk1->GetFlags()&AliESDtrack::kTOFmismatch)) && (intL > 0) && (timeTOF > 0)){
1654 
1655  betaPiK = intL/2.99792458e-2/timeTOF;
1656 
1657  nSigmaPi = TMath::Sqrt(nSigPiTPC*nSigPiTPC + nSigPiTOF*nSigPiTOF);
1658  nSigmaK = TMath::Sqrt(nSigKTPC*nSigKTPC + nSigKTOF*nSigKTOF);
1659 
1660  }
1661  if (aodTrk1->Pt() < 0.4){
1662  if (aodTrk1->GetTPCsignal() <= 60)
1663  nSigmaPi = TMath::Abs(nSigPiTPC);
1664  if (aodTrk1->GetTPCsignal() >= 110)
1665  nSigmaK = TMath::Abs(nSigKTPC);
1666  }
1667 
1668  //p
1669  if ((aodTrk1->Pt() >= 0.5) && (aodTrk1->GetFlags()&AliESDtrack::kTOFout) && (aodTrk1->GetFlags()&AliESDtrack::kTIME) && (!(aodTrk1->GetFlags()&AliESDtrack::kTOFmismatch)) && (intL > 0) && (timeTOF > 0)){
1670 
1671  betaP = intL/2.99792458e-2/timeTOF;
1672 
1673  nSigmaP = TMath::Sqrt(nSigPTPC*nSigPTPC + nSigPTOF*nSigPTOF);
1674 
1675  }
1676  if (aodTrk1->Pt() < 0.5) {
1677  if (aodTrk1->GetTPCsignal() >= 110)
1678  nSigmaP = TMath::Abs(nSigPTPC);
1679  }
1680 
1681 
1682  //exclusive PID
1683  if (fExclPID){
1684  if ( (nSigmaPi < fNsigCut && nSigmaK < fNsigCut) || (nSigmaPi < fNsigCut && nSigmaP < fNsigCut) || (nSigmaK < fNsigCut && nSigmaP < fNsigCut) )
1685  continue;
1686  }
1687 
1688 
1689  Short_t minSigma = FindMinNSigma(nSigmaPi, nSigmaK, nSigmaP);
1690 
1691  if (minSigma == 0)
1692  continue;
1693 
1694  if ((nSigmaK == nSigmaPi) && (nSigmaK == nSigmaP))
1695  continue;
1696 
1697 
1698  Short_t pidFl = -1;
1699 
1700  //pi
1701  if (aodTrk1->Pt() < 4. && minSigma == 1 && !GetDoubleCountingPi(nSigmaPi, minSigma) && ((aodTrk1->Pt() >= 0.4 && betaPiK > 0.4) || (aodTrk1->Pt() < 0.4 && betaPiK < 0))){
1702 
1703  Double_t rapPi = GetRapidity(0.139570, aodTrk1->Pt(), aodTrk1->Eta());
1704 
1705  if (TMath::Abs(rapPi) < 0.5){
1706 
1707  if (!fBin1Cent){
1708  fVnPiA[centrCode]->Fill(aodTrk1->Pt(), vnSPV0A);
1709  fVnPiC[centrCode]->Fill(aodTrk1->Pt(), vnSPV0C);
1710  } else {
1711  fVnPiAB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0A);
1712  fVnPiCB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0C);
1713  }
1714 
1715  pidFl = 0;
1716  }
1717 
1718  }
1719 
1720  //K
1721  if (aodTrk1->Pt() < 4. && minSigma == 2 && !GetDoubleCountingK(nSigmaK, minSigma) && ((aodTrk1->Pt() >= 0.4 && betaPiK > 0.4) || (aodTrk1->Pt() < 0.4 && betaPiK < 0))){
1722 
1723  Double_t rapK = GetRapidity(0.493667, aodTrk1->Pt(), aodTrk1->Eta());
1724 
1725  if (TMath::Abs(rapK) < 0.5){
1726 
1727  if (!fBin1Cent){
1728  fVnKA[centrCode]->Fill(aodTrk1->Pt(), vnSPV0A);
1729  fVnKC[centrCode]->Fill(aodTrk1->Pt(), vnSPV0C);
1730  } else {
1731  fVnKAB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0A);
1732  fVnKCB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0C);
1733  }
1734 
1735  pidFl = 1;
1736 
1737  }
1738 
1739  }
1740 
1741  //p
1742  if (aodTrk1->Pt() < 4. && minSigma == 3 && !GetDoubleCountingP(nSigmaP, minSigma) && ((aodTrk1->Pt() >= 0.5 && betaP > 0.4) || (aodTrk1->Pt() < 0.5 && betaP < 0))){
1743 
1744  if ((aodTrk1->Charge() < 0 && aodTrk1->Pt() < 2.) || (aodTrk1->Pt() >= 2.)){
1745 
1746  Double_t rapP = GetRapidity(0.938272, aodTrk1->Pt(), aodTrk1->Eta());
1747 
1748  if (TMath::Abs(rapP) < 0.5){
1749 
1750  if (!fBin1Cent){
1751  fVnAntiPA[centrCode]->Fill(aodTrk1->Pt(), vnSPV0A);
1752  fVnAntiPC[centrCode]->Fill(aodTrk1->Pt(), vnSPV0C);
1753  } else {
1754  fVnAntiPAB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0A);
1755  fVnAntiPCB1C[iCentV0]->Fill(aodTrk1->Pt(), vnSPV0C);
1756  }
1757 
1758  pidFl = 2;
1759 
1760  }
1761 
1762  }
1763 
1764  }
1765 
1766 
1767  if (fQA && pidFl >= 0 && aodTrk1->Pt() < 4.){
1768 
1769  Float_t dedx = aodTrk1->GetTPCsignal();
1770 
1771  Double_t beta = 0;
1772  if (pidFl < 2)
1773  beta = betaPiK;
1774  else
1775  beta = betaP;
1776 
1777  if (!fBin1Cent){
1778  Double_t pidQA[6] = {Double_t(centrCode),
1779  dedx,
1780  beta,
1781  Double_t(aodTrk1->Charge()),
1782  Double_t(pidFl),
1783  aodTrk1->P()};
1784  fPidQA->Fill(pidQA);
1785 
1786  } else {
1787  Double_t pidQAB1C[6] = {Double_t(iCentV0),
1788  dedx,
1789  beta,
1790  Double_t(aodTrk1->Charge()),
1791  Double_t(pidFl),
1792  aodTrk1->P()};
1793  fPidQAB1C->Fill(pidQAB1C);
1794 
1795  }
1796 
1797  }
1798 
1799  }
1800 
1801 
1802 
1803 
1804  const Int_t nv0s = aod->GetNumberOfV0s();
1805 
1806  Double_t lPrimaryVtxPosition[3];
1807  aod->GetPrimaryVertex()->GetXYZ(lPrimaryVtxPosition);
1808 
1809  //v0 vn
1810  for (Int_t jV0 = 0; jV0 < nv0s; jV0++) {
1811 
1812  AliAODv0* v0 = (AliAODv0*) aod->GetV0(jV0);
1813 
1814  if (!v0){
1815  delete v0;
1816  continue;
1817  }
1818 
1819 
1820  if (fEtaRange == 0){
1821  if (v0->Eta() >= 0)
1822  continue;
1823  }
1824 
1825  if (fEtaRange == 1){
1826  if (v0->Eta() < 0)
1827  continue;
1828  }
1829 
1830 
1831  // V0 cuts
1832  Double_t lDcaPosToPrimVertex = v0->DcaPosToPrimVertex();
1833  Double_t lDcaNegToPrimVertex = v0->DcaNegToPrimVertex();
1834  Double_t lV0CosineOfPointingAngle = v0->CosPointingAngle(aod->GetPrimaryVertex());
1835  Double_t lDcaV0Daughters = v0->DcaV0Daughters();
1836  Double_t lV0Radius = v0->RadiusV0();
1837 
1838  Double_t lV0Position[3];
1839  v0->GetXYZ(lV0Position);
1840  Double_t lV0DecayLength = TMath::Sqrt(TMath::Power(lV0Position[0] - lPrimaryVtxPosition[0],2) +
1841  TMath::Power(lV0Position[1] - lPrimaryVtxPosition[1],2) +
1842  TMath::Power(lV0Position[2] - lPrimaryVtxPosition[2],2));
1843 
1844  if ( (lDcaPosToPrimVertex < fDCADghtPV) || (lDcaNegToPrimVertex < fDCADghtPV) || (lDcaV0Daughters > fMaxDCADght) || (lV0CosineOfPointingAngle < fCosPA) || (lV0Radius < fMinRad) || (lV0Radius > fMaxRad) || (v0->Pt() < fMinPt) || (v0->Pt() >= fMaxPt) || (TMath::Abs(v0->Eta()) >= fEtaCut) )
1845  continue;
1846 
1847 
1848 
1849  if (fArmPodCut){
1850 
1851  Double_t ptArm = v0->PtArmV0();
1852  Double_t angAlpha = v0->AlphaV0();
1853 
1854  if (ptArm <= 0.2*TMath::Abs(angAlpha))
1855  continue;
1856 
1857  }
1858 
1859 
1860 
1861  // Tracks quality cuts
1862  const AliAODTrack* negTrack = (AliAODTrack *)v0->GetDaughter(1);
1863  if (!negTrack){
1864  delete negTrack;
1865  continue;
1866  }
1867 
1868  const AliAODTrack* posTrack =(AliAODTrack *)v0->GetDaughter(0);
1869  if (!posTrack){
1870  delete posTrack;
1871  continue;
1872  }
1873 
1874 
1875  if (!posTrack->IsOn(AliAODTrack::kTPCrefit))
1876  continue;
1877 
1878  if (!negTrack->IsOn(AliAODTrack::kTPCrefit))
1879  continue;
1880 
1881 
1882 
1883  if (posTrack->Charge() == negTrack->Charge()){
1884  //cout<< "like sign, continue"<< endl;
1885  continue;
1886  }
1887 
1888 
1889  if ((posTrack->GetTPCNcls() < fNoClus) || (negTrack->GetTPCNcls() < fNoClus))
1890  continue;
1891 
1892 
1893  Float_t nCrossedRowsTPCPos = posTrack->GetTPCNCrossedRows();
1894  if (nCrossedRowsTPCPos < fNoClus)
1895  continue;
1896  Int_t findablePos = posTrack->GetTPCNclsF();
1897  if (findablePos <= 0)
1898  continue;
1899  if (nCrossedRowsTPCPos/findablePos < fNcrFind)
1900  continue;
1901 
1902 
1903  Float_t nCrossedRowsTPCNeg = negTrack->GetTPCNCrossedRows();
1904  if (nCrossedRowsTPCNeg < fNoClus)
1905  continue;
1906  Int_t findableNeg = negTrack->GetTPCNclsF();
1907  if (findableNeg <= 0)
1908  continue;
1909  if (nCrossedRowsTPCNeg/findableNeg < fNcrFind)
1910  continue;
1911 
1912 
1913  if (TMath::Abs(posTrack->Eta()) > fEtaCut || TMath::Abs(negTrack->Eta()) > fEtaCut)
1914  continue;
1915 
1916 
1917  if (fMinPtDght){
1918  if (posTrack->Pt() < fMinPt || negTrack->Pt() < fMinPt)
1919  continue;
1920  }
1921 
1922 
1923 
1924  if (negTrack->GetTPCsignalN() < fNoClusPid || posTrack->GetTPCsignalN() < fNoClusPid)
1925  continue;
1926 
1927  Double_t nSigmaPipos = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(posTrack, AliPID::kPion));
1928  Double_t nSigmaPineg = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(negTrack, AliPID::kPion));
1929 
1930  Double_t nSigmaPpos = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(posTrack, AliPID::kProton));
1931  Double_t nSigmaPneg = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(negTrack, AliPID::kProton));
1932 
1933 
1934 
1935  Int_t iPtV = GetPtBin(v0->Pt());
1936  if (iPtV < 0)
1937  continue;
1938 
1939 
1940  Double_t lInvMassK0s = v0->MassK0Short();
1941  Double_t lInvMassL = v0->MassLambda();
1942 
1943  Short_t flagV0 = -1;
1944 
1945  //K0
1946  if (nSigmaPipos < fNsigCut && nSigmaPineg < fNsigCut && lInvMassK0s > 0.4 && lInvMassK0s < 0.6){
1947 
1948  Double_t rapK0 = GetRapidity(0.497648, v0->Pt(), v0->Eta());
1949 
1950  if (TMath::Abs(rapK0) < 0.5){
1951 
1952  Double_t vnK0V0C = TMath::Cos(fNHarm*v0->Phi())*QxcnCor + TMath::Sin(fNHarm*v0->Phi())*QycnCor;
1953  Double_t vnK0V0A = TMath::Cos(fNHarm*v0->Phi())*QxanCor + TMath::Sin(fNHarm*v0->Phi())*QyanCor;
1954 
1955  fInvMassK0[iPtV][centrCode]->Fill(lInvMassK0s);
1956  fVnK0A[iPtV][centrCode]->Fill(lInvMassK0s, vnK0V0A);
1957  fVnK0C[iPtV][centrCode]->Fill(lInvMassK0s, vnK0V0C);
1958 
1959  if (iCentV0 == 0){
1960 
1961  fInvMassK0B1C[iPtV][iCentV0]->Fill(lInvMassK0s);
1962  fVnK0AB1C[iPtV][iCentV0]->Fill(lInvMassK0s, vnK0V0A);
1963  fVnK0CB1C[iPtV][iCentV0]->Fill(lInvMassK0s, vnK0V0C);
1964 
1965  }
1966 
1967  flagV0 = 0;
1968 
1969  }
1970 
1971  }
1972 
1973 
1974  //Lambda
1975  if ( ((nSigmaPpos < fNsigCut && nSigmaPineg < fNsigCut) || (nSigmaPneg < fNsigCut || nSigmaPipos < fNsigCut)) && lInvMassL > 1.07 && lInvMassL < 1.17){
1976 
1977  Double_t rapL = GetRapidity(1.115683, v0->Pt(), v0->Eta());
1978 
1979  if (TMath::Abs(rapL) < 0.5){
1980 
1981  Double_t vnLV0C = TMath::Cos(fNHarm*v0->Phi())*QxcnCor + TMath::Sin(fNHarm*v0->Phi())*QycnCor;
1982  Double_t vnLV0A = TMath::Cos(fNHarm*v0->Phi())*QxanCor + TMath::Sin(fNHarm*v0->Phi())*QyanCor;
1983 
1984  fInvMassL[iPtV][centrCode]->Fill(lInvMassL);
1985  fVnLA[iPtV][centrCode]->Fill(lInvMassL, vnLV0A);
1986  fVnLC[iPtV][centrCode]->Fill(lInvMassL, vnLV0C);
1987 
1988  if (iCentV0 == 0){
1989 
1990  fInvMassLB1C[iPtV][iCentV0]->Fill(lInvMassL);
1991  fVnLAB1C[iPtV][iCentV0]->Fill(lInvMassL, vnLV0A);
1992  fVnLCB1C[iPtV][iCentV0]->Fill(lInvMassL, vnLV0C);
1993 
1994  }
1995 
1996  flagV0 = 1;
1997 
1998  }
1999 
2000  }
2001 
2002  if (fQA && flagV0 >= 0){
2003 
2004  Double_t v0Data[8] = {Double_t(centrCode),
2005  v0->Pt(),
2006  lDcaPosToPrimVertex,
2007  lDcaNegToPrimVertex,
2008  lV0CosineOfPointingAngle,
2009  lDcaV0Daughters,
2010  lV0Radius,
2011  (Double_t)flagV0};
2012  fV0QA->Fill(v0Data);
2013 
2014  }
2015 
2016 
2017  }
2018 
2019 
2020  Double_t corV0AV0Cvn = QxanCor*QxcnCor + QyanCor*QycnCor;
2021  Double_t corV0ATPCvn = QxanCor*Qxtn + QyanCor*Qytn;
2022  Double_t corV0CTPCvn = QxcnCor*Qxtn + QycnCor*Qytn;
2023 
2024  if (!fBin1Cent){
2025 
2026  fV0AV0Cvn->Fill(v0Centr, corV0AV0Cvn);
2027  fV0ATPCvn->Fill(v0Centr, corV0ATPCvn);
2028  fV0CTPCvn->Fill(v0Centr, corV0CTPCvn);
2029 
2030  fV0AV0Cvnsq->Fill(v0Centr, corV0AV0Cvn*corV0AV0Cvn);
2031  fV0ATPCvnsq->Fill(v0Centr, corV0ATPCvn*corV0ATPCvn);
2032  fV0CTPCvnsq->Fill(v0Centr, corV0CTPCvn*corV0CTPCvn);
2033 
2034  } else {
2035 
2036  fV0AV0CvnB1C->Fill(v0Centr, corV0AV0Cvn);
2037  fV0ATPCvnB1C->Fill(v0Centr, corV0ATPCvn);
2038  fV0CTPCvnB1C->Fill(v0Centr, corV0CTPCvn);
2039 
2040  fV0AV0CvnB1Csq->Fill(v0Centr, corV0AV0Cvn*corV0AV0Cvn);
2041  fV0ATPCvnB1Csq->Fill(v0Centr, corV0ATPCvn*corV0ATPCvn);
2042  fV0CTPCvnB1Csq->Fill(v0Centr, corV0CTPCvn*corV0CTPCvn);
2043  }
2044 
2045 }
2046 
2047 //_____________________________________________________________________________
2049 {
2050 
2051  if (!gGrid) {
2052  TGrid::Connect("alien://");
2053  }
2054 
2055 
2056  TFile* foadb = 0;
2057  if (!fRemChV0A)
2058  foadb = TFile::Open("alien:///alice/cern.ch/user/a/adobrin/calibV0HIR.root");
2059  else
2060  foadb = TFile::Open("alien:///alice/cern.ch/user/a/adobrin/calibV0HIRNoCh46V0A.root");
2061 
2062 
2063  if(!foadb){
2064  printf("OADB V0 calibration file cannot be opened\n");
2065  return;
2066  }
2067 
2068  AliOADBContainer* cont = (AliOADBContainer*) foadb->Get("hMultV0BefCorPfpx");
2069  if(!cont){
2070  printf("OADB object hMultV0BefCorr is not available in the file\n");
2071  return;
2072  }
2073  if(!(cont->GetObject(run))){
2074  printf("OADB object hMultV0BefCorPfpx is not available for run %i\n", run);
2075  return;
2076  }
2077  fMultV0 = ((TH1D*) cont->GetObject(run));
2078 
2079 
2080 
2081  AliOADBContainer* contQxnam = 0;
2082  if (fNHarm == 2.)
2083  contQxnam = (AliOADBContainer*) foadb->Get("fqxa2m");
2084  else
2085  contQxnam = (AliOADBContainer*) foadb->Get("fqxa3m");
2086 
2087  if(!contQxnam){
2088  printf("OADB object fqxanm is not available in the file\n");
2089  return;
2090  }
2091  if(!(contQxnam->GetObject(run))){
2092  printf("OADB object fqxanm is not available for run %i\n", run);
2093  return;
2094  }
2095  fQxnmV0A = ((TH1D*) contQxnam->GetObject(run));
2096 
2097 
2098 
2099  AliOADBContainer* contQynam = 0;
2100  if (fNHarm == 2.)
2101  contQynam = (AliOADBContainer*) foadb->Get("fqya2m");
2102  else if (fNHarm == 3.)
2103  contQynam = (AliOADBContainer*) foadb->Get("fqya3m");
2104  else if (fNHarm == 4.)
2105  contQynam = (AliOADBContainer*) foadb->Get("fqya4m");
2106 
2107  if(!contQynam){
2108  printf("OADB object fqyanm is not available in the file\n");
2109  return;
2110  }
2111  if(!(contQynam->GetObject(run))){
2112  printf("OADB object fqyanm is not available for run %i\n", run);
2113  return;
2114  }
2115  fQynmV0A = ((TH1D*) contQynam->GetObject(run));
2116 
2117 
2118 
2119  AliOADBContainer* contQxnas = 0;
2120  if (fNHarm == 2.)
2121  contQxnas = (AliOADBContainer*) foadb->Get("fqxa2s");
2122  else
2123  contQxnas = (AliOADBContainer*) foadb->Get("fqxa3s");
2124 
2125  if(!contQxnas){
2126  printf("OADB object fqxans is not available in the file\n");
2127  return;
2128  }
2129  if(!(contQxnas->GetObject(run))){
2130  printf("OADB object fqxans is not available for run %i\n", run);
2131  return;
2132  }
2133  fQxnsV0A = ((TH1D*) contQxnas->GetObject(run));
2134 
2135 
2136 
2137  AliOADBContainer* contQynas = 0;
2138  if (fNHarm == 2.)
2139  contQynas = (AliOADBContainer*) foadb->Get("fqya2s");
2140  else if (fNHarm == 3.)
2141  contQynas = (AliOADBContainer*) foadb->Get("fqya3s");
2142  else if (fNHarm == 4.)
2143  contQynas = (AliOADBContainer*) foadb->Get("fqya4s");
2144 
2145  if(!contQynas){
2146  printf("OADB object fqyans is not available in the file\n");
2147  return;
2148  }
2149  if(!(contQynas->GetObject(run))){
2150  printf("OADB object fqyans is not available for run %i\n", run);
2151  return;
2152  }
2153  fQynsV0A = ((TH1D*) contQynas->GetObject(run));
2154 
2155 
2156 
2157  AliOADBContainer* contQxncm = 0;
2158  if (fNHarm == 2.)
2159  contQxncm = (AliOADBContainer*) foadb->Get("fqxc2m");
2160  else
2161  contQxncm = (AliOADBContainer*) foadb->Get("fqxc3m");
2162 
2163  if(!contQxncm){
2164  printf("OADB object fqxcnm is not available in the file\n");
2165  return;
2166  }
2167  if(!(contQxncm->GetObject(run))){
2168  printf("OADB object fqxcnm is not available for run %i\n", run);
2169  return;
2170  }
2171  fQxnmV0C = ((TH1D*) contQxncm->GetObject(run));
2172 
2173 
2174 
2175  AliOADBContainer* contQyncm = 0;
2176  if (fNHarm == 2.)
2177  contQyncm = (AliOADBContainer*) foadb->Get("fqyc2m");
2178  else if (fNHarm == 3.)
2179  contQyncm = (AliOADBContainer*) foadb->Get("fqyc3m");
2180  else if (fNHarm == 4.)
2181  contQyncm = (AliOADBContainer*) foadb->Get("fqyc4m");
2182 
2183  if(!contQyncm){
2184  printf("OADB object fqyc2m is not available in the file\n");
2185  return;
2186  }
2187  if(!(contQyncm->GetObject(run))){
2188  printf("OADB object fqyc2m is not available for run %i\n", run);
2189  return;
2190  }
2191  fQynmV0C = ((TH1D*) contQyncm->GetObject(run));
2192 
2193 
2194 
2195  AliOADBContainer* contQxncs = 0;
2196  if (fNHarm == 2.)
2197  contQxncs = (AliOADBContainer*) foadb->Get("fqxc2s");
2198  else
2199  contQxncs = (AliOADBContainer*) foadb->Get("fqxc3s");
2200 
2201  if(!contQxncs){
2202  printf("OADB object fqxc2s is not available in the file\n");
2203  return;
2204  }
2205  if(!(contQxncs->GetObject(run))){
2206  printf("OADB object fqxc2s is not available for run %i\n", run);
2207  return;
2208  }
2209  fQxnsV0C = ((TH1D*) contQxncs->GetObject(run));
2210 
2211 
2212 
2213  AliOADBContainer* contQyncs = 0;
2214  if (fNHarm == 2.)
2215  contQyncs = (AliOADBContainer*) foadb->Get("fqyc2s");
2216  else if (fNHarm == 3.)
2217  contQyncs = (AliOADBContainer*) foadb->Get("fqyc3s");
2218  else if (fNHarm == 4.)
2219  contQyncs = (AliOADBContainer*) foadb->Get("fqyc4s");
2220 
2221  if(!contQyncs){
2222  printf("OADB object fqycnm is not available in the file\n");
2223  return;
2224  }
2225  if(!(contQyncs->GetObject(run))){
2226  printf("OADB object fqycns is not available for run %i\n", run);
2227  return;
2228  }
2229  fQynsV0C = ((TH1D*) contQyncs->GetObject(run));
2230 
2231 }
2232 
2233 //_____________________________________________________________________________
2235 {
2236 
2237  Float_t vtxz = -999;
2238 
2239  const AliAODVertex* trkVtx = aod->GetPrimaryVertex();
2240  if (!trkVtx || trkVtx->GetNContributors()<=0)
2241  return vtxz;
2242 
2243  vtxz = trkVtx->GetZ();
2244 
2245  return vtxz;
2246 }
2247 
2248 //_____________________________________________________________________________
2249 Double_t AliAnalysisTaskPiKpK0Lamba::GetWDist(const AliVVertex* v0, const AliVVertex* v1)
2250 {
2251 
2252  // calculate sqrt of weighted distance to other vertex
2253  if (!v0 || !v1) {
2254  printf("One of vertices is not valid\n");
2255  return 0;
2256  }
2257  static TMatrixDSym vVb(3);
2258  double dist = -1;
2259  double dx = v0->GetX()-v1->GetX();
2260  double dy = v0->GetY()-v1->GetY();
2261  double dz = v0->GetZ()-v1->GetZ();
2262  double cov0[6],cov1[6];
2263  v0->GetCovarianceMatrix(cov0);
2264  v1->GetCovarianceMatrix(cov1);
2265  vVb(0,0) = cov0[0]+cov1[0];
2266  vVb(1,1) = cov0[2]+cov1[2];
2267  vVb(2,2) = cov0[5]+cov1[5];
2268  vVb(1,0) = vVb(0,1) = cov0[1]+cov1[1];
2269  vVb(0,2) = vVb(1,2) = vVb(2,0) = vVb(2,1) = 0.;
2270  vVb.InvertFast();
2271  if (!vVb.IsValid()) {printf("Singular Matrix\n"); return dist;}
2272  dist = vVb(0,0)*dx*dx + vVb(1,1)*dy*dy + vVb(2,2)*dz*dz
2273  + 2*vVb(0,1)*dx*dy + 2*vVb(0,2)*dx*dz + 2*vVb(1,2)*dy*dz;
2274  return dist>0 ? TMath::Sqrt(dist) : -1;
2275 
2276 }
2277 
2278 
2279 //_____________________________________________________________________________
2281 {
2282  // check for multi-vertexer pile-up
2283  const AliAODEvent *aod = (const AliAODEvent*)event;
2284  const AliESDEvent *esd = (const AliESDEvent*)event;
2285  //
2286  const int kMinPlpContrib = 5;
2287  const double kMaxPlpChi2 = 5.0;
2288  const double kMinWDist = 15;
2289  //
2290  if (!aod && !esd) {
2291  printf("Event is neither of AOD nor ESD\n");
2292  exit(1);
2293  }
2294  //
2295  const AliVVertex* vtPrm = 0;
2296  const AliVVertex* vtPlp = 0;
2297  int nPlp = 0;
2298  //
2299  if (aod) {
2300  if ( !(nPlp=aod->GetNumberOfPileupVerticesTracks()) ) return kFALSE;
2301  vtPrm = aod->GetPrimaryVertex();
2302  if (vtPrm == aod->GetPrimaryVertexSPD()) return kTRUE; // there are pile-up vertices but no primary
2303  }
2304  else {
2305  if ( !(nPlp=esd->GetNumberOfPileupVerticesTracks())) return kFALSE;
2306  vtPrm = esd->GetPrimaryVertexTracks();
2307  if (((AliESDVertex*)vtPrm)->GetStatus()!=1) return kTRUE; // there are pile-up vertices but no primary
2308  }
2309 
2310  //int bcPrim = vtPrm->GetBC();
2311  //
2312  for (int ipl=0;ipl<nPlp;ipl++) {
2313  vtPlp = aod ? (const AliVVertex*)aod->GetPileupVertexTracks(ipl) : (const AliVVertex*)esd->GetPileupVertexTracks(ipl);
2314  //
2315  if (vtPlp->GetNContributors() < kMinPlpContrib) continue;
2316  if (vtPlp->GetChi2perNDF() > kMaxPlpChi2) continue;
2317  // int bcPlp = vtPlp->GetBC();
2318  // if (bcPlp!=AliVTrack::kTOFBCNA && TMath::Abs(bcPlp-bcPrim)>2) return kTRUE; // pile-up from other BC
2319  //
2320  double wDst = GetWDist(vtPrm,vtPlp);
2321  if (wDst<kMinWDist) continue;
2322  //
2323  return kTRUE; // pile-up: well separated vertices
2324  }
2325  //
2326  return kFALSE;
2327  //
2328 }
2329 
2330 //---------------------------------------------------
2332 {
2333 
2334  Short_t kPID = 0;
2335 
2336  if((nSk == nSpi) && (nSk == nSp))
2337  return kPID;
2338 
2339  if((nSk < nSpi) && (nSk < nSp) && (nSk < fNsigCut))
2340  kPID = 2;
2341 
2342  if((nSpi < nSk) && (nSpi < nSp) && (nSpi < fNsigCut))
2343  kPID = 1;
2344 
2345  if((nSp < nSk) && (nSp < nSpi) && (nSp < fNsigCut))
2346  kPID = 3;
2347 
2348  return kPID;
2349 
2350 }
2351 
2352 //_____________________________________________________________________________
2354 {
2355 
2356  Bool_t piDC = kFALSE;
2357 
2358  if (nSpi < fNsigCut && minNSigma != 1)
2359  piDC = kTRUE;
2360 
2361  return piDC;
2362 
2363 }
2364 
2365 //_____________________________________________________________________________
2367 {
2368 
2369  Bool_t kDC = kFALSE;
2370 
2371  if (nSk < fNsigCut && minNSigma != 2)
2372  kDC = kTRUE;
2373 
2374  return kDC;
2375 
2376 }
2377 
2378 //_____________________________________________________________________________
2380 {
2381 
2382  Bool_t pDC = kFALSE;
2383 
2384  if (nSp < fNsigCut && minNSigma != 3)
2385  pDC = kTRUE;
2386 
2387  return pDC;
2388 
2389 }
2390 
2391 //__________________________________________________________
2393 {
2394 
2395  Double_t rapid = TMath::Log( (TMath::Sqrt(mass*mass + Pt*Pt*TMath::CosH(Eta)*TMath::CosH(Eta)) + Pt*TMath::SinH(Eta)) / TMath::Sqrt(mass*mass + Pt*Pt) );
2396  return rapid;
2397 
2398 }
2399 
2400 //____________________________________________________________________
2402 {
2403 
2404  Int_t ptBin = -10;
2405 
2406  for (Int_t iPt = 0; iPt < fNPtBins; iPt++){
2407 
2408  if(valPt >= fPtBins[iPt] && valPt < fPtBins[iPt+1])
2409  ptBin = iPt;
2410 
2411  }
2412 
2413  return ptBin;
2414 
2415 }
2416 
2417 //_____________________________________________________________________________
2419 {
2420  // Terminate loop
2421  Printf("Terminate()");
2422 }
TProfile * fSinTrkSinV0C[10]
cos(Trk)cos(V0A) for debug
TProfile * fVnPihighPtCB1C[90]
vn V0C anti-p
TH2D * fMultESDDifvsMultTPCBef
multiplicity FB vs FB+TOF after
TProfile * fCosTrkSinV0C[10]
sin(Trk)cos(V0C) for debug
TProfile * fVnPhighPtC[10]
vn V0C pi+ + pi-
Bool_t GetDoubleCountingK(Double_t nSk, Short_t minNSigma)
TH2I * fSPclsvsSPDtrksBef
multiplicity dif ESD-3.38*TPC vs TPC after
TProfile * fVnKC[10]
vn V0C pi+ + pi-
TH2D * fQyavsVtxZBef
corrected Qx V0A vtx
double Double_t
Definition: External.C:58
TProfile * fSinTrkCosV0A[10]
correlation PsiA-PsiC
TProfile * fVnAllCB1C[90]
vn V0A anti-p + p
TH1F * fCentrBef
Multiplicity vs centrality.
TH2F * fMultV0vsMultTPCoutBef
SPD clusters vs tracklets after.
Definition: External.C:236
TH2F * fCenCL1vsV0MAft
CL0-V0M correlation before.
TH1D * fPsiA[10]
vn V0C anti-p + p
TProfile * fVnK0A[17][10]
inv mass K0
TProfile * fVnAntiPCB1C[90]
vn V0C K+ + K-
Double_t GetWDist(const AliVVertex *v0, const AliVVertex *v1)
TProfile * fVnKCB1C[90]
vn V0C pi+ + pi-
TProfile * fSinTrkSinV0A[10]
cos(Trk)sin(V0C) for debug
TProfile * fCosTrkCosV0AB1C[90]
sin(Trk)sin(V0A) for debug
TProfile * fV0AV0CvnB1Csq
correlation V0C-TPC for resolution
TProfile * fVnK0C[17][10]
vn V0A K0
Double_t mass
TH2D * fQycvsVtxZBef
corrected Qx V0C vtx
TH1D * fInvMassLB1C[17][1]
vn V0C K0
TH2D * fQyavsVtxZAft
corrected Qx V0A vtx
TProfile * fCosTrkCosV0C[10]
sin(Trk)sin(V0C) for debug
TProfile * fSinTrkCosV0CB1C[90]
cos(Trk)sin(V0A) for debug
TH2F * fCenCL0vsCL1Bef
CL0-V0M correlation before.
TH2I * fMultFBvsMultFBTOFAft
multiplicity FB vs FB+TOF before
TH1D * fPsiAB1C[90]
vn V0C anti-p + p
TProfile * fVnPiAB1C[90]
vn V0A all
AliPIDResponse * fPIDResponse
AOD object.
TH2F * fCenCL1vsV0MBef
CL0-V0M correlation before.
TProfile * fV0CTPCvnB1Csq
correlation V0A-TPC for resolution
virtual void Analyze(AliAODEvent *aod, Float_t vtxZ)
TH1D * fInvMassL[17][10]
vn V0C K0
TH2D * fQycvsV0Bef
corrected Qx V0C cent
TProfile * fVnLAB1C[17][1]
inv mass Lambda
TProfile * fSinTrkSinV0AB1C[90]
cos(Trk)sin(V0C) for debug
TProfile * fV0CTPCvnsq
correlation V0A-TPC for resolution
TProfile * fVnKA[10]
vn V0A pi+ + pi-
virtual Float_t GetVertex(AliAODEvent *aod) const
TProfile * fVnAllAB1C[90]
vn V0A Lambda
TH2D * fQxavsV0Aft
corrected Qx V0C vtx
TH1F * fVtxAfterCuts
Vertex z dist before cuts.
TH2D * fQycvsV0Aft
corrected Qx V0C cent
TH2D * fQyavsV0Aft
corrected Qx V0A cent
TH1F * fCentrAft
centrality distribution
TH1I * fVtx
Output list of objects.
TH1F * fVtxBeforeCuts
Event vertex info.
TProfile * fV0ATPCvn
correlation V0A-V0C for resolution
TH2D * fQxavsVtxZAft
corrected Qx V0C cent
THnSparseF * fPidQA
multV0-multTPCout before
TProfile * fVnPiC[10]
vn V0C all
TH2D * fQxavsVtxZBef
corrected Qx V0C cent
TProfile * fVnPihighPtA[10]
vn V0A anti-p
int Int_t
Definition: External.C:63
TH2D * fQxcvsVtxZAft
corrected Qy V0A vtx
Definition: External.C:204
Bool_t GetDoubleCountingPi(Double_t nSpi, Short_t minNSigma)
virtual void UserExec(Option_t *option)
TProfile * fSinTrkCosV0C[10]
cos(Trk)sin(V0A) for debug
float Float_t
Definition: External.C:68
TProfile * fVnPhighPtCB1C[90]
vn V0C pi+ + pi-
TH1D * fInvMassK0B1C[17][1]
vn V0A Lambda
TH2F * fCenCL0vsV0MAft
CL0-CL1 correlation before.
TProfile * fCosTrkCosV0A[10]
sin(Trk)sin(V0A) for debug
TProfile * fV0CTPCvn
correlation V0A-TPC for resolution
Definition: External.C:228
Definition: External.C:212
TProfile * fV0ATPCvnB1Csq
correlation V0A-V0C for resolution
TProfile * fV0AV0Cvn
corrected Qx V0C vtx
TH2D * fMultESDDifvsMultTPCAft
multiplicity dif ESD-3.38*TPC vs TPC before
TH2D * fQxcvsV0Bef
corrected Qy V0A cent
Bool_t GetDoubleCountingP(Double_t nSp, Short_t minNSigma)
TH2I * fMultFBvsMultFBTOFBef
CL0-CL1 correlation before.
TH1D * fInvMassK0[17][10]
cos(Trk)cos(V0C) for debug
TH2F * fMultvsCentAft
Multiplicity vs centrality.
THnSparseF * fAllQAB1C
qa histo for tracks
TH2F * fCenCL0vsCL1Aft
CL0-V0M correlation before.
short Short_t
Definition: External.C:23
Int_t GetPtBin(Double_t valPt) const
TProfile * fCosTrkSinV0A[10]
sin(Trk)cos(V0A) for debug
TProfile * fVnPhighPtAB1C[90]
vn V0A pi+ + pi-
TProfile * fVnPihighPtC[10]
vn V0C anti-p
TH2D * fQycvsVtxZAft
corrected Qx V0C vtx
TProfile * fVnPiA[10]
vn V0A all
TProfile * fV0AV0Cvnsq
correlation V0C-TPC for resolution
TProfile * fCosTrkSinV0CB1C[90]
sin(Trk)cos(V0C) for debug
TProfile * fVnLC[17][10]
vn V0A Lambda
TProfile * fV0ATPCvnsq
correlation V0A-V0C for resolution
TH2D * fQxcvsV0Aft
corrected Qy V0A cent
THnSparseF * fPidQAB1C
qa histo for V0
TProfile * fV0ATPCvnB1C
correlation V0A-V0C for resolution
TProfile * fVnLA[17][10]
inv mass Lambda
Int_t fRun
pid response object
THnSparseF * fAllQA
qa histo for tracks
TProfile * fVnAntiPC[10]
vn V0C K+ + K-
TH2F * fCenCL0vsV0MBef
centrality distribution
TProfile * fVnAntiPA[10]
vn V0A K+ + K-
THnSparseF * fV0QA
qa histo for tracks
const char Option_t
Definition: External.C:48
TProfile * fVnAllA[10]
correlation V0C-TPC for resolution
Double_t GetRapidity(Double_t mass, Double_t Pt, Double_t Eta)
TProfile * fVnPhighPtA[10]
vn V0A pi+ + pi-
TProfile * fVnPihighPtAB1C[90]
vn V0A anti-p
TProfile * fV0AV0CvnB1C
correlation V0C-TPC for resolution
TH2F * fMultvsCentBef
Vertex z dist after cuts.
TH2D * fQxcvsVtxZBef
corrected Qy V0A vtx
TH2D * fQyavsV0Bef
corrected Qx V0A cent
bool Bool_t
Definition: External.C:53
TProfile * fSinTrkCosV0AB1C[90]
correlation PsiA-PsiC
TProfile * fCosTrkCosV0CB1C[90]
sin(Trk)sin(V0C) for debug
TProfile * fCosTrkSinV0AB1C[90]
sin(Trk)cos(V0A) for debug
TProfile * fVnLCB1C[17][1]
vn V0A Lambda
TProfile * fVnK0AB1C[17][1]
inv mass K0
TProfile * fVnK0CB1C[17][1]
vn V0A K0
Short_t FindMinNSigma(Double_t nSpi, Double_t nSk, Double_t nSp)
TProfile * fV0CTPCvnB1C
correlation V0A-TPC for resolution
TProfile * fVnKAB1C[90]
vn V0A pi+ + pi-
TH2F * fMultV0vsMultTPCoutAft
multV0-multTPCout before
TProfile * fSinTrkSinV0CB1C[90]
cos(Trk)cos(V0A) for debug
TProfile * fVnAllC[10]
vn V0A anti-p + p
TProfile * fVnPiCB1C[90]
vn V0C all
TList * OpenFile(const char *fname)
Definition: DrawAnaELoss.C:65
TProfile * fVnAntiPAB1C[90]
vn V0A K+ + K-
TH2I * fSPclsvsSPDtrksAft
SPD clusters vs tracklets before.
TH2D * fQxavsV0Bef
qa histo for tracks
Bool_t plpMV(const AliVEvent *event)