AliPhysics  aaf9c62 (aaf9c62)
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  Int_t statfly = v0->GetOnFlyStatus();
1820  if (statfly == 1) continue;
1821 
1822  if (fEtaRange == 0){
1823  if (v0->Eta() >= 0)
1824  continue;
1825  }
1826 
1827  if (fEtaRange == 1){
1828  if (v0->Eta() < 0)
1829  continue;
1830  }
1831 
1832 
1833  // V0 cuts
1834  Double_t lDcaPosToPrimVertex = v0->DcaPosToPrimVertex();
1835  Double_t lDcaNegToPrimVertex = v0->DcaNegToPrimVertex();
1836  Double_t lV0CosineOfPointingAngle = v0->CosPointingAngle(aod->GetPrimaryVertex());
1837  Double_t lDcaV0Daughters = v0->DcaV0Daughters();
1838  Double_t lV0Radius = v0->RadiusV0();
1839 
1840  Double_t lV0Position[3];
1841  v0->GetXYZ(lV0Position);
1842 // Double_t lV0DecayLength = TMath::Sqrt(TMath::Power(lV0Position[0] - lPrimaryVtxPosition[0],2) +
1843 // TMath::Power(lV0Position[1] - lPrimaryVtxPosition[1],2) +
1844 // TMath::Power(lV0Position[2] - lPrimaryVtxPosition[2],2));
1845 
1846  if ( (lDcaPosToPrimVertex < fDCADghtPV) || (lDcaNegToPrimVertex < fDCADghtPV) || (lDcaV0Daughters > fMaxDCADght) || (lV0CosineOfPointingAngle < fCosPA) || (lV0Radius < fMinRad) || (lV0Radius > fMaxRad) || (v0->Pt() < fMinPt) || (v0->Pt() >= fMaxPt) || (TMath::Abs(v0->Eta()) >= fEtaCut) )
1847  continue;
1848 
1849 
1850 
1851  if (fArmPodCut){
1852 
1853  Double_t ptArm = v0->PtArmV0();
1854  Double_t angAlpha = v0->AlphaV0();
1855 
1856  if (ptArm <= 0.2*TMath::Abs(angAlpha))
1857  continue;
1858 
1859  }
1860 
1861 
1862 
1863  // Tracks quality cuts
1864  const AliAODTrack* negTrack = (AliAODTrack *)v0->GetDaughter(1);
1865  if (!negTrack){
1866  delete negTrack;
1867  continue;
1868  }
1869 
1870  const AliAODTrack* posTrack =(AliAODTrack *)v0->GetDaughter(0);
1871  if (!posTrack){
1872  delete posTrack;
1873  continue;
1874  }
1875 
1876 
1877  if (!posTrack->IsOn(AliAODTrack::kTPCrefit))
1878  continue;
1879 
1880  if (!negTrack->IsOn(AliAODTrack::kTPCrefit))
1881  continue;
1882 
1883 
1884 
1885  if (posTrack->Charge() == negTrack->Charge()){
1886  //cout<< "like sign, continue"<< endl;
1887  continue;
1888  }
1889 
1890 
1891  if ((posTrack->GetTPCNcls() < fNoClus) || (negTrack->GetTPCNcls() < fNoClus))
1892  continue;
1893 
1894 
1895  Float_t nCrossedRowsTPCPos = posTrack->GetTPCNCrossedRows();
1896  if (nCrossedRowsTPCPos < fNoClus)
1897  continue;
1898  Int_t findablePos = posTrack->GetTPCNclsF();
1899  if (findablePos <= 0)
1900  continue;
1901  if (nCrossedRowsTPCPos/findablePos < fNcrFind)
1902  continue;
1903 
1904 
1905  Float_t nCrossedRowsTPCNeg = negTrack->GetTPCNCrossedRows();
1906  if (nCrossedRowsTPCNeg < fNoClus)
1907  continue;
1908  Int_t findableNeg = negTrack->GetTPCNclsF();
1909  if (findableNeg <= 0)
1910  continue;
1911  if (nCrossedRowsTPCNeg/findableNeg < fNcrFind)
1912  continue;
1913 
1914 
1915  if (TMath::Abs(posTrack->Eta()) > fEtaCut || TMath::Abs(negTrack->Eta()) > fEtaCut)
1916  continue;
1917 
1918 
1919  if (fMinPtDght){
1920  if (posTrack->Pt() < fMinPt || negTrack->Pt() < fMinPt)
1921  continue;
1922  }
1923 
1924 
1925 
1926  if (negTrack->GetTPCsignalN() < fNoClusPid || posTrack->GetTPCsignalN() < fNoClusPid)
1927  continue;
1928 
1929  Double_t nSigmaPipos = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(posTrack, AliPID::kPion));
1930  Double_t nSigmaPineg = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(negTrack, AliPID::kPion));
1931 
1932  Double_t nSigmaPpos = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(posTrack, AliPID::kProton));
1933  Double_t nSigmaPneg = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(negTrack, AliPID::kProton));
1934 
1935 
1936 
1937  Int_t iPtV = GetPtBin(v0->Pt());
1938  if (iPtV < 0)
1939  continue;
1940 
1941 
1942  Double_t lInvMassK0s = v0->MassK0Short();
1943  Double_t lInvMassL = v0->MassLambda();
1944 
1945  Short_t flagV0 = -1;
1946 
1947  //K0
1948  if (nSigmaPipos < fNsigCut && nSigmaPineg < fNsigCut && lInvMassK0s > 0.4 && lInvMassK0s < 0.6){
1949 
1950  Double_t rapK0 = GetRapidity(0.497648, v0->Pt(), v0->Eta());
1951 
1952  if (TMath::Abs(rapK0) < 0.5){
1953 
1954  Double_t vnK0V0C = TMath::Cos(fNHarm*v0->Phi())*QxcnCor + TMath::Sin(fNHarm*v0->Phi())*QycnCor;
1955  Double_t vnK0V0A = TMath::Cos(fNHarm*v0->Phi())*QxanCor + TMath::Sin(fNHarm*v0->Phi())*QyanCor;
1956 
1957  fInvMassK0[iPtV][centrCode]->Fill(lInvMassK0s);
1958  fVnK0A[iPtV][centrCode]->Fill(lInvMassK0s, vnK0V0A);
1959  fVnK0C[iPtV][centrCode]->Fill(lInvMassK0s, vnK0V0C);
1960 
1961  if (iCentV0 == 0){
1962 
1963  fInvMassK0B1C[iPtV][iCentV0]->Fill(lInvMassK0s);
1964  fVnK0AB1C[iPtV][iCentV0]->Fill(lInvMassK0s, vnK0V0A);
1965  fVnK0CB1C[iPtV][iCentV0]->Fill(lInvMassK0s, vnK0V0C);
1966 
1967  }
1968 
1969  flagV0 = 0;
1970 
1971  }
1972 
1973  }
1974 
1975 
1976  //Lambda
1977  if ( ((nSigmaPpos < fNsigCut && nSigmaPineg < fNsigCut) || (nSigmaPneg < fNsigCut || nSigmaPipos < fNsigCut)) && lInvMassL > 1.07 && lInvMassL < 1.17){
1978 
1979  Double_t rapL = GetRapidity(1.115683, v0->Pt(), v0->Eta());
1980 
1981  if (TMath::Abs(rapL) < 0.5){
1982 
1983  Double_t vnLV0C = TMath::Cos(fNHarm*v0->Phi())*QxcnCor + TMath::Sin(fNHarm*v0->Phi())*QycnCor;
1984  Double_t vnLV0A = TMath::Cos(fNHarm*v0->Phi())*QxanCor + TMath::Sin(fNHarm*v0->Phi())*QyanCor;
1985 
1986  fInvMassL[iPtV][centrCode]->Fill(lInvMassL);
1987  fVnLA[iPtV][centrCode]->Fill(lInvMassL, vnLV0A);
1988  fVnLC[iPtV][centrCode]->Fill(lInvMassL, vnLV0C);
1989 
1990  if (iCentV0 == 0){
1991 
1992  fInvMassLB1C[iPtV][iCentV0]->Fill(lInvMassL);
1993  fVnLAB1C[iPtV][iCentV0]->Fill(lInvMassL, vnLV0A);
1994  fVnLCB1C[iPtV][iCentV0]->Fill(lInvMassL, vnLV0C);
1995 
1996  }
1997 
1998  flagV0 = 1;
1999 
2000  }
2001 
2002  }
2003 
2004  if (fQA && flagV0 >= 0){
2005 
2006  Double_t v0Data[8] = {Double_t(centrCode),
2007  v0->Pt(),
2008  lDcaPosToPrimVertex,
2009  lDcaNegToPrimVertex,
2010  lV0CosineOfPointingAngle,
2011  lDcaV0Daughters,
2012  lV0Radius,
2013  (Double_t)flagV0};
2014  fV0QA->Fill(v0Data);
2015 
2016  }
2017 
2018 
2019  }
2020 
2021 
2022  Double_t corV0AV0Cvn = QxanCor*QxcnCor + QyanCor*QycnCor;
2023  Double_t corV0ATPCvn = QxanCor*Qxtn + QyanCor*Qytn;
2024  Double_t corV0CTPCvn = QxcnCor*Qxtn + QycnCor*Qytn;
2025 
2026  Double_t corV0AV0Cvnsq = QxanCor*QxanCor*QxcnCor*QxcnCor - QyanCor*QyanCor*QxcnCor*QxcnCor + 4.*QxanCor*QxcnCor*QyanCor*QycnCor - QxanCor*QxanCor*QycnCor*QycnCor + QyanCor*QyanCor*QycnCor*QycnCor;
2027  Double_t corV0ATPCvnsq = QxanCor*QxanCor*Qxtn*Qxtn - QyanCor*QyanCor*Qxtn*Qxtn + 4.*QxanCor*Qxtn*QyanCor*Qytn - QxanCor*QxanCor*Qytn*Qytn + QyanCor*QyanCor*Qytn*Qytn;
2028  Double_t corV0CTPCvnsq = QxcnCor*QxcnCor*Qxtn*Qxtn - QycnCor*QycnCor*Qxtn*Qxtn + 4.*QxcnCor*Qxtn*QycnCor*Qytn - QxcnCor*QxcnCor*Qytn*Qytn + QycnCor*QycnCor*Qytn*Qytn;
2029 
2030 
2031 
2032  if (!fBin1Cent){
2033 
2034 
2035 
2036 
2037  fV0AV0Cvn->Fill(v0Centr, corV0AV0Cvn);
2038  fV0ATPCvn->Fill(v0Centr, corV0ATPCvn);
2039  fV0CTPCvn->Fill(v0Centr, corV0CTPCvn);
2040 /*
2041  fV0AV0Cvnsq->Fill(v0Centr, corV0AV0Cvn*corV0AV0Cvn);
2042  fV0ATPCvnsq->Fill(v0Centr, corV0ATPCvn*corV0ATPCvn);
2043  fV0CTPCvnsq->Fill(v0Centr, corV0CTPCvn*corV0CTPCvn);
2044 */
2045  fV0AV0Cvnsq->Fill(v0Centr, corV0AV0Cvnsq);
2046  fV0ATPCvnsq->Fill(v0Centr, corV0ATPCvnsq);
2047  fV0CTPCvnsq->Fill(v0Centr, corV0CTPCvnsq);
2048  } else {
2049 
2050  fV0AV0CvnB1C->Fill(v0Centr, corV0AV0Cvn);
2051  fV0ATPCvnB1C->Fill(v0Centr, corV0ATPCvn);
2052  fV0CTPCvnB1C->Fill(v0Centr, corV0CTPCvn);
2053 /*
2054  fV0AV0CvnB1Csq->Fill(v0Centr, corV0AV0Cvn*corV0AV0Cvn);
2055  fV0ATPCvnB1Csq->Fill(v0Centr, corV0ATPCvn*corV0ATPCvn);
2056  fV0CTPCvnB1Csq->Fill(v0Centr, corV0CTPCvn*corV0CTPCvn);
2057 */
2058  fV0AV0CvnB1Csq->Fill(v0Centr, corV0AV0Cvnsq);
2059  fV0ATPCvnB1Csq->Fill(v0Centr, corV0ATPCvnsq);
2060  fV0CTPCvnB1Csq->Fill(v0Centr, corV0CTPCvnsq);
2061 
2062 
2063 
2064  }
2065 
2066 }
2067 
2068 //_____________________________________________________________________________
2070 {
2071 
2072  if (!gGrid) {
2073  TGrid::Connect("alien://");
2074  }
2075 
2076 
2077  TFile* foadb = 0;
2078  if (!fRemChV0A)
2079  foadb = TFile::Open("alien:///alice/cern.ch/user/a/adobrin/calibV0HIR.root");
2080  else
2081  foadb = TFile::Open("alien:///alice/cern.ch/user/a/adobrin/calibV0HIRNoCh46V0A.root");
2082 
2083 
2084  if(!foadb){
2085  printf("OADB V0 calibration file cannot be opened\n");
2086  return;
2087  }
2088 
2089  AliOADBContainer* cont = (AliOADBContainer*) foadb->Get("hMultV0BefCorPfpx");
2090  if(!cont){
2091  printf("OADB object hMultV0BefCorr is not available in the file\n");
2092  return;
2093  }
2094  if(!(cont->GetObject(run))){
2095  printf("OADB object hMultV0BefCorPfpx is not available for run %i\n", run);
2096  return;
2097  }
2098  fMultV0 = ((TH1D*) cont->GetObject(run));
2099 
2100 
2101 
2102  AliOADBContainer* contQxnam = 0;
2103  if (fNHarm == 2.)
2104  contQxnam = (AliOADBContainer*) foadb->Get("fqxa2m");
2105  else
2106  contQxnam = (AliOADBContainer*) foadb->Get("fqxa3m");
2107 
2108  if(!contQxnam){
2109  printf("OADB object fqxanm is not available in the file\n");
2110  return;
2111  }
2112  if(!(contQxnam->GetObject(run))){
2113  printf("OADB object fqxanm is not available for run %i\n", run);
2114  return;
2115  }
2116  fQxnmV0A = ((TH1D*) contQxnam->GetObject(run));
2117 
2118 
2119 
2120  AliOADBContainer* contQynam = 0;
2121  if (fNHarm == 2.)
2122  contQynam = (AliOADBContainer*) foadb->Get("fqya2m");
2123  else if (fNHarm == 3.)
2124  contQynam = (AliOADBContainer*) foadb->Get("fqya3m");
2125  else if (fNHarm == 4.)
2126  contQynam = (AliOADBContainer*) foadb->Get("fqya4m");
2127 
2128  if(!contQynam){
2129  printf("OADB object fqyanm is not available in the file\n");
2130  return;
2131  }
2132  if(!(contQynam->GetObject(run))){
2133  printf("OADB object fqyanm is not available for run %i\n", run);
2134  return;
2135  }
2136  fQynmV0A = ((TH1D*) contQynam->GetObject(run));
2137 
2138 
2139 
2140  AliOADBContainer* contQxnas = 0;
2141  if (fNHarm == 2.)
2142  contQxnas = (AliOADBContainer*) foadb->Get("fqxa2s");
2143  else
2144  contQxnas = (AliOADBContainer*) foadb->Get("fqxa3s");
2145 
2146  if(!contQxnas){
2147  printf("OADB object fqxans is not available in the file\n");
2148  return;
2149  }
2150  if(!(contQxnas->GetObject(run))){
2151  printf("OADB object fqxans is not available for run %i\n", run);
2152  return;
2153  }
2154  fQxnsV0A = ((TH1D*) contQxnas->GetObject(run));
2155 
2156 
2157 
2158  AliOADBContainer* contQynas = 0;
2159  if (fNHarm == 2.)
2160  contQynas = (AliOADBContainer*) foadb->Get("fqya2s");
2161  else if (fNHarm == 3.)
2162  contQynas = (AliOADBContainer*) foadb->Get("fqya3s");
2163  else if (fNHarm == 4.)
2164  contQynas = (AliOADBContainer*) foadb->Get("fqya4s");
2165 
2166  if(!contQynas){
2167  printf("OADB object fqyans is not available in the file\n");
2168  return;
2169  }
2170  if(!(contQynas->GetObject(run))){
2171  printf("OADB object fqyans is not available for run %i\n", run);
2172  return;
2173  }
2174  fQynsV0A = ((TH1D*) contQynas->GetObject(run));
2175 
2176 
2177 
2178  AliOADBContainer* contQxncm = 0;
2179  if (fNHarm == 2.)
2180  contQxncm = (AliOADBContainer*) foadb->Get("fqxc2m");
2181  else
2182  contQxncm = (AliOADBContainer*) foadb->Get("fqxc3m");
2183 
2184  if(!contQxncm){
2185  printf("OADB object fqxcnm is not available in the file\n");
2186  return;
2187  }
2188  if(!(contQxncm->GetObject(run))){
2189  printf("OADB object fqxcnm is not available for run %i\n", run);
2190  return;
2191  }
2192  fQxnmV0C = ((TH1D*) contQxncm->GetObject(run));
2193 
2194 
2195 
2196  AliOADBContainer* contQyncm = 0;
2197  if (fNHarm == 2.)
2198  contQyncm = (AliOADBContainer*) foadb->Get("fqyc2m");
2199  else if (fNHarm == 3.)
2200  contQyncm = (AliOADBContainer*) foadb->Get("fqyc3m");
2201  else if (fNHarm == 4.)
2202  contQyncm = (AliOADBContainer*) foadb->Get("fqyc4m");
2203 
2204  if(!contQyncm){
2205  printf("OADB object fqyc2m is not available in the file\n");
2206  return;
2207  }
2208  if(!(contQyncm->GetObject(run))){
2209  printf("OADB object fqyc2m is not available for run %i\n", run);
2210  return;
2211  }
2212  fQynmV0C = ((TH1D*) contQyncm->GetObject(run));
2213 
2214 
2215 
2216  AliOADBContainer* contQxncs = 0;
2217  if (fNHarm == 2.)
2218  contQxncs = (AliOADBContainer*) foadb->Get("fqxc2s");
2219  else
2220  contQxncs = (AliOADBContainer*) foadb->Get("fqxc3s");
2221 
2222  if(!contQxncs){
2223  printf("OADB object fqxc2s is not available in the file\n");
2224  return;
2225  }
2226  if(!(contQxncs->GetObject(run))){
2227  printf("OADB object fqxc2s is not available for run %i\n", run);
2228  return;
2229  }
2230  fQxnsV0C = ((TH1D*) contQxncs->GetObject(run));
2231 
2232 
2233 
2234  AliOADBContainer* contQyncs = 0;
2235  if (fNHarm == 2.)
2236  contQyncs = (AliOADBContainer*) foadb->Get("fqyc2s");
2237  else if (fNHarm == 3.)
2238  contQyncs = (AliOADBContainer*) foadb->Get("fqyc3s");
2239  else if (fNHarm == 4.)
2240  contQyncs = (AliOADBContainer*) foadb->Get("fqyc4s");
2241 
2242  if(!contQyncs){
2243  printf("OADB object fqycnm is not available in the file\n");
2244  return;
2245  }
2246  if(!(contQyncs->GetObject(run))){
2247  printf("OADB object fqycns is not available for run %i\n", run);
2248  return;
2249  }
2250  fQynsV0C = ((TH1D*) contQyncs->GetObject(run));
2251 
2252 }
2253 
2254 //_____________________________________________________________________________
2256 {
2257 
2258  Float_t vtxz = -999;
2259 
2260  const AliAODVertex* trkVtx = aod->GetPrimaryVertex();
2261  if (!trkVtx || trkVtx->GetNContributors()<=0)
2262  return vtxz;
2263 
2264  vtxz = trkVtx->GetZ();
2265 
2266  return vtxz;
2267 }
2268 
2269 //_____________________________________________________________________________
2270 Double_t AliAnalysisTaskPiKpK0Lamba::GetWDist(const AliVVertex* v0, const AliVVertex* v1)
2271 {
2272 
2273  // calculate sqrt of weighted distance to other vertex
2274  if (!v0 || !v1) {
2275  printf("One of vertices is not valid\n");
2276  return 0;
2277  }
2278  static TMatrixDSym vVb(3);
2279  double dist = -1;
2280  double dx = v0->GetX()-v1->GetX();
2281  double dy = v0->GetY()-v1->GetY();
2282  double dz = v0->GetZ()-v1->GetZ();
2283  double cov0[6],cov1[6];
2284  v0->GetCovarianceMatrix(cov0);
2285  v1->GetCovarianceMatrix(cov1);
2286  vVb(0,0) = cov0[0]+cov1[0];
2287  vVb(1,1) = cov0[2]+cov1[2];
2288  vVb(2,2) = cov0[5]+cov1[5];
2289  vVb(1,0) = vVb(0,1) = cov0[1]+cov1[1];
2290  vVb(0,2) = vVb(1,2) = vVb(2,0) = vVb(2,1) = 0.;
2291  vVb.InvertFast();
2292  if (!vVb.IsValid()) {printf("Singular Matrix\n"); return dist;}
2293  dist = vVb(0,0)*dx*dx + vVb(1,1)*dy*dy + vVb(2,2)*dz*dz
2294  + 2*vVb(0,1)*dx*dy + 2*vVb(0,2)*dx*dz + 2*vVb(1,2)*dy*dz;
2295  return dist>0 ? TMath::Sqrt(dist) : -1;
2296 
2297 }
2298 
2299 
2300 //_____________________________________________________________________________
2302 {
2303  // check for multi-vertexer pile-up
2304  const AliAODEvent *aod = (const AliAODEvent*)event;
2305  const AliESDEvent *esd = (const AliESDEvent*)event;
2306  //
2307  const int kMinPlpContrib = 5;
2308  const double kMaxPlpChi2 = 5.0;
2309  const double kMinWDist = 15;
2310  //
2311  if (!aod && !esd) {
2312  printf("Event is neither of AOD nor ESD\n");
2313  exit(1);
2314  }
2315  //
2316  const AliVVertex* vtPrm = 0;
2317  const AliVVertex* vtPlp = 0;
2318  int nPlp = 0;
2319  //
2320  if (aod) {
2321  if ( !(nPlp=aod->GetNumberOfPileupVerticesTracks()) ) return kFALSE;
2322  vtPrm = aod->GetPrimaryVertex();
2323  if (vtPrm == aod->GetPrimaryVertexSPD()) return kTRUE; // there are pile-up vertices but no primary
2324  }
2325  else {
2326  if ( !(nPlp=esd->GetNumberOfPileupVerticesTracks())) return kFALSE;
2327  vtPrm = esd->GetPrimaryVertexTracks();
2328  if (((AliESDVertex*)vtPrm)->GetStatus()!=1) return kTRUE; // there are pile-up vertices but no primary
2329  }
2330 
2331  //int bcPrim = vtPrm->GetBC();
2332  //
2333  for (int ipl=0;ipl<nPlp;ipl++) {
2334  vtPlp = aod ? (const AliVVertex*)aod->GetPileupVertexTracks(ipl) : (const AliVVertex*)esd->GetPileupVertexTracks(ipl);
2335  //
2336  if (vtPlp->GetNContributors() < kMinPlpContrib) continue;
2337  if (vtPlp->GetChi2perNDF() > kMaxPlpChi2) continue;
2338  // int bcPlp = vtPlp->GetBC();
2339  // if (bcPlp!=AliVTrack::kTOFBCNA && TMath::Abs(bcPlp-bcPrim)>2) return kTRUE; // pile-up from other BC
2340  //
2341  double wDst = GetWDist(vtPrm,vtPlp);
2342  if (wDst<kMinWDist) continue;
2343  //
2344  return kTRUE; // pile-up: well separated vertices
2345  }
2346  //
2347  return kFALSE;
2348  //
2349 }
2350 
2351 //---------------------------------------------------
2353 {
2354 
2355  Short_t kPID = 0;
2356 
2357  if((nSk == nSpi) && (nSk == nSp))
2358  return kPID;
2359 
2360  if((nSk < nSpi) && (nSk < nSp) && (nSk < fNsigCut))
2361  kPID = 2;
2362 
2363  if((nSpi < nSk) && (nSpi < nSp) && (nSpi < fNsigCut))
2364  kPID = 1;
2365 
2366  if((nSp < nSk) && (nSp < nSpi) && (nSp < fNsigCut))
2367  kPID = 3;
2368 
2369  return kPID;
2370 
2371 }
2372 
2373 //_____________________________________________________________________________
2375 {
2376 
2377  Bool_t piDC = kFALSE;
2378 
2379  if (nSpi < fNsigCut && minNSigma != 1)
2380  piDC = kTRUE;
2381 
2382  return piDC;
2383 
2384 }
2385 
2386 //_____________________________________________________________________________
2388 {
2389 
2390  Bool_t kDC = kFALSE;
2391 
2392  if (nSk < fNsigCut && minNSigma != 2)
2393  kDC = kTRUE;
2394 
2395  return kDC;
2396 
2397 }
2398 
2399 //_____________________________________________________________________________
2401 {
2402 
2403  Bool_t pDC = kFALSE;
2404 
2405  if (nSp < fNsigCut && minNSigma != 3)
2406  pDC = kTRUE;
2407 
2408  return pDC;
2409 
2410 }
2411 
2412 //__________________________________________________________
2414 {
2415 
2416  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) );
2417  return rapid;
2418 
2419 }
2420 
2421 //____________________________________________________________________
2423 {
2424 
2425  Int_t ptBin = -10;
2426 
2427  for (Int_t iPt = 0; iPt < fNPtBins; iPt++){
2428 
2429  if(valPt >= fPtBins[iPt] && valPt < fPtBins[iPt+1])
2430  ptBin = iPt;
2431 
2432  }
2433 
2434  return ptBin;
2435 
2436 }
2437 
2438 //_____________________________________________________________________________
2440 {
2441  // Terminate loop
2442  Printf("Terminate()");
2443 }
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)