AliPhysics  608b256 (608b256)
AliAnalysisTaskQAflow.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 
16 // AliAnalysisTaskQAflow: some simple QA used in flow analysis
17 
18 #include "TMath.h"
19 #include "TH1D.h"
20 #include "TH2D.h"
21 #include "TSeqCollection.h"
22 #include "TObjArray.h"
23 #include "TObjArray.h"
24 #include "TChain.h"
25 #include "TMCProcess.h"
26 #include "TLorentzVector.h"
27 #include "TDirectory.h"
28 #include "TROOT.h"
29 #include "TNtuple.h"
30 
31 #include "AliLog.h"
32 #include "AliVParticle.h"
33 #include "AliMCParticle.h"
34 #include "AliStack.h"
35 #include "AliVEvent.h"
36 #include "AliESDEvent.h"
37 #include "AliMCEvent.h"
38 #include "AliESDVZERO.h"
39 #include "AliESDZDC.h"
40 #include "AliESDtrack.h"
41 #include "AliFlowTrackCuts.h"
42 #include "AliFlowEventCuts.h"
43 #include "AliMultiplicity.h"
44 #include "AliESDtrackCuts.h"
45 #include "AliVertex.h"
46 #include "AliFlowEventSimple.h"
47 #include "AliFlowEvent.h"
48 #include "AliFlowVector.h"
49 
50 #include "AliAnalysisTaskSE.h"
51 #include "AliAnalysisManager.h"
52 #include "AliInputEventHandler.h"
53 
54 #include "AliAnalysisTaskQAflow.h"
55 
56 ClassImp(AliAnalysisTaskQAflow)
57 
58 //________________________________________________________________________
61  fOutput(NULL),
62  fFillNtuple(kFALSE),
63  fDoCorrelations(kFALSE),
64  fNtuple(NULL),
65  fEventCuts(NULL),
66  fTrackCuts(NULL)
67 {
68  // Default constructor
69 }
70 
71 //________________________________________________________________________
73  : AliAnalysisTaskSE(name),
74  fOutput(NULL),
75  fFillNtuple(kFALSE),
76  fDoCorrelations(kFALSE),
77  fNtuple(NULL),
78  fEventCuts(NULL),
79  fTrackCuts(NULL)
80 {
81  // Constructor
82  DefineInput(1, AliFlowEventSimple::Class());
83  DefineOutput(1, TObjArray::Class());
84  DefineOutput(2,TNtuple::Class());
85 }
86 
87 //________________________________________________________________________
89 {
90  // Called once at the beginning
91  fOutput=new TObjArray();
92  fNtuple = new TNtuple("flowQAtree","flowQAtree","mpt:qx:qy:mul:rmul:phys:vtxtpcx:vtxtpcy:vtxtpcz:ntra:ntrc:mv0a:mv0c:zdcp1:zdcn1:zdcp2:zdcn2:zdcpart1:zdcpart2:t1:t2:t3:t4:t5:vtxspdx:vtxspdy:vtxspdz:vtxx:vtxy:vtxz:rawmeanpt:maxpt:qxp:qyp:qxn:qyn:qxa:qya:qxb:qyb:qm:qmp:qmn:qma:qmb");
93  //TDirectory* before = gDirectory->mkdir("before cuts","before cuts");
94  //TDirectory* after = gDirectory->mkdir("after cuts","after cuts");
95  TObjArray* before = new TObjArray();
96  TObjArray* after = new TObjArray();
97  fOutput->Add(before);
98  fOutput->Add(after);
99 
100  //define histograms
101 
102  TH1* hist;
103  hist = new TH1I("all_tracklet_multiplicity","all tracklets",5000,0,5000);
104  before->Add(hist); after->Add(hist->Clone()); //0
105  hist = new TH1I("rptrack_multiplicity", "RP selection track multiplicity",5000,0,5000);
106  before->Add(hist); after->Add(hist->Clone()); //1
107  hist = new TH1I("rprefmult","RP selection refmult",30000, 0,30000);
108  before->Add(hist); after->Add(hist->Clone()); //2
109  hist = new TH1I("SPD_clusters","SPD clusters",10000,0,10000);
110  before->Add(hist); after->Add(hist->Clone()); //3
111  hist = new TH1D("primary_vertexZ","primary vertex z",1000,-20,20);
112  before->Add(hist); after->Add(hist->Clone()); //4
113  hist = new TH1I("ITS_clusters_on_track", "ITS clusters on track", 8, 0, 8);
114  before->Add(hist); after->Add(hist->Clone()); //5
115  hist = new TH1I("TPC_clusters_on_track", "TPC clusters on track", 159, 1, 160);
116  before->Add(hist); after->Add(hist->Clone()); //6
117  hist = new TH1D("TPC_chi2_per_cluster","TPC #chi^{2}/cluster",1000,0.0,5.0);
118  before->Add(hist); after->Add(hist->Clone()); //7
119  hist = new TH1D("DCA_xy","DCA xy", 1000, -5.0, 5.0 );
120  before->Add(hist); after->Add(hist->Clone()); //8
121  hist = new TH1D("DCA_z","DCA z", 1000, -5.0, 5.0 );
122  before->Add(hist); after->Add(hist->Clone()); //9
123  hist = new TH1D("phi_tracklets","#phi tracklets", 1000, 0.0, TMath::TwoPi() );
124  before->Add(hist); after->Add(hist->Clone()); //10
125  hist = new TH1D("phi_tracks","#phi tracks", 1000, 0.0, TMath::TwoPi() );
126  before->Add(hist); after->Add(hist->Clone()); //11
127  hist = new TH1D("eta_tracklets","#eta tracklets", 1000, -2.0, 2.0 );
128  before->Add(hist); after->Add(hist->Clone()); //12
129  hist = new TH1D("eta_tracks","#eta tracks", 1000, -2.0, 2.0 );
130  before->Add(hist); after->Add(hist->Clone()); //13
131  hist = new TH1D("TPC_vertex_z", "TPC vertex z", 1000,-20.0,20.0);
132  before->Add(hist); after->Add(hist->Clone()); //14
133  hist = new TH1D("ptyield", "p_{t} spectrum", 10000,0.0,10.0);
134  before->Add(hist); after->Add(hist->Clone()); //15
135  hist = new TH1D("ptyieldplus", "p_{t} spectrum +", 10000,0.0,10.0);
136  before->Add(hist); after->Add(hist->Clone()); //16
137  hist = new TH1D("ptyieldneg", "p_{t} spectrum -", 10000,0.0,10.0);
138  before->Add(hist); after->Add(hist->Clone()); //17
139  hist = new TH1D("charges", "charge distribution", 5,-2.5,2.5);
140  before->Add(hist); after->Add(hist->Clone()); //18
141  hist = new TH1D("dphivsdeta", "#Delta#phi separation", 10000,-TMath::PiOver2(),TMath::Pi()+TMath::PiOver2());
142  before->Add(hist); after->Add(hist->Clone()); //19
143  hist = new TH1I("standardTPC_multiplicity", "standard TPC track multiplicity",10000,0,10000);
144  before->Add(hist); after->Add(hist->Clone()); //20
145  hist = new TH1I("standardV0_multiplicity", "standard V0 multiplicity",30000,0,30000);
146  before->Add(hist); after->Add(hist->Clone()); //21
147  hist = new TH1I("standardSPD1clusters_multiplicity", "standard SPD1 clusters multiplicity",30000,0,30000);
148  before->Add(hist); after->Add(hist->Clone()); //22
149  hist = new TH1I("standardSPDtracklets_multiplicity", "standard SPD tracklets multiplicity",30000,0,30000);
150  before->Add(hist); after->Add(hist->Clone()); //23
151 
152  //post data here as it doesn't change anyway (the pointer to list anyway)
153 
154  PostData(1, fOutput);
155  PostData(2, fNtuple);
156 }
157 
158 //________________________________________________________________________
160 {
161 
162  //get teh input data
163  AliESDEvent* event = dynamic_cast<AliESDEvent*>(InputEvent());
164  if (!event)
165  {
166  AliFatal("no ESD event");
167  return;
168  }
169  fTrackCuts->SetEvent(event);
170 
171  //TObjArray* before = ((TDirectory*)fOutput->At(0))->GetList();
172  //TObjArray* after = ((TDirectory*)fOutput->At(1))->GetList();
173  TObjArray* before = (TObjArray*)fOutput->At(0);
174  TObjArray* after = (TObjArray*)fOutput->At(1);
175  TH1* htrackletmultB = static_cast<TH1*>(before->At(0));
176  TH1* htrackletmultA = static_cast<TH1*>(after->At(0));
177  TH1* htrackmultB = static_cast<TH1*>(before->At(1));
178  TH1* htrackmultA = static_cast<TH1*>(after->At(1));
179  TH1* hrefmultB = static_cast<TH1*>(before->At(2));
180  TH1* hrefmultA = static_cast<TH1*>(after->At(2));
181  TH1* hspdclustersB = static_cast<TH1*>(before->At(3));
182  TH1* hspdclustersA = static_cast<TH1*>(after->At(3));
183  TH1* hprimvtxzB = static_cast<TH1*>(before->At(4));
184  TH1* hprimvtxzA = static_cast<TH1*>(after->At(4));
185 
186  TH1* hITSclsB = static_cast<TH1*>(before->At(5));
187  TH1* hITSclsA = static_cast<TH1*>(after->At(5));
188  TH1* hTPCclsB = static_cast<TH1*>(before->At(6));
189  TH1* hTPCclsA = static_cast<TH1*>(after->At(6));
190  TH1* hTPCchi2B = static_cast<TH1*>(before->At(7));
191  TH1* hTPCchi2A = static_cast<TH1*>(after->At(7));
192  TH1* hdcaxyB = static_cast<TH1*>(before->At(8));
193  TH1* hdcaxyA = static_cast<TH1*>(after->At(8));
194  TH1* hdcazB = static_cast<TH1*>(before->At(9));
195  TH1* hdcazA = static_cast<TH1*>(after->At(9));
196  TH1* hphitrackletsB = static_cast<TH1*>(before->At(10));
197  TH1* hphitrackletsA = static_cast<TH1*>(after->At(10));
198  TH1* hphitracksB = static_cast<TH1*>(before->At(11));
199  TH1* hphitracksA = static_cast<TH1*>(after->At(11));
200  TH1* hetatrackletsB = static_cast<TH1*>(before->At(12));
201  TH1* hetatrackletsA = static_cast<TH1*>(after->At(12));
202  TH1* hetatracksB = static_cast<TH1*>(before->At(13));
203  TH1* hetatracksA = static_cast<TH1*>(after->At(13));
204  TH1* hprimvtxzTPCB = static_cast<TH1*>(before->At(14));
205  TH1* hprimvtxzTPCA = static_cast<TH1*>(after->At(14));
206  TH1* hptyieldB = static_cast<TH1*>(before->At(15));
207  TH1* hptyieldA = static_cast<TH1*>(after->At(15));
208  TH1* hptyieldplusB = static_cast<TH1*>(before->At(16));
209  TH1* hptyieldplusA = static_cast<TH1*>(after->At(16));
210  TH1* hptyieldnegB = static_cast<TH1*>(before->At(17));
211  TH1* hptyieldnegA = static_cast<TH1*>(after->At(17));
212  TH1* hchargesB = static_cast<TH1*>(before->At(18));
213  TH1* hchargesA = static_cast<TH1*>(after->At(18));
214  TH1* hphisepB = static_cast<TH1*>(before->At(19));
215  TH1* hphisepA = static_cast<TH1*>(after->At(19));
216  TH1* hstdtpcmultB = static_cast<TH1*>(before->At(20));
217  TH1* hstdtpcmultA = static_cast<TH1*>(after->At(20));
218  TH1* hstdv0multB = static_cast<TH1*>(before->At(21));
219  TH1* hstdv0multA = static_cast<TH1*>(after->At(21));
220  TH1* hstdspd1clsmultB = static_cast<TH1*>(before->At(22));
221  TH1* hstdspd1clsmultA = static_cast<TH1*>(after->At(22));
222  TH1* hstdspdtrmultB = static_cast<TH1*>(before->At(23));
223  TH1* hstdspdtrmultA = static_cast<TH1*>(after->At(23));
224 
225  Bool_t passevent = fEventCuts->IsSelected(event,0x0);
226  Bool_t isSelectedEventSelection = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
227 
228  AliMultiplicity* tracklets = const_cast<AliMultiplicity*>(event->GetMultiplicity());
229  Int_t ntracklets=0;
230  Int_t nspdclusters=0;
231  Int_t ntrackletsA=0;
232  Int_t ntrackletsC=0;
233  if (tracklets)
234  {
235  ntracklets = tracklets->GetNumberOfTracklets();
236  nspdclusters = tracklets->GetNumberOfITSClusters(0,1);
237  for (Int_t i=0; i<tracklets->GetNumberOfTracklets(); i++)
238  {
239  Bool_t pass=fTrackCuts->IsSelected(tracklets,i);
240  Float_t phi=tracklets->GetPhi(i);
241  Float_t eta=tracklets->GetEta(i);
242  hphitrackletsB->Fill(phi); if (pass) hphitrackletsA->Fill(phi);
243  hetatrackletsB->Fill(eta); if (pass) hetatrackletsA->Fill(eta);
244  if (eta>0) ntrackletsC++;
245  else ntrackletsA++;
246  }
247  }
248 
249  AliFlowEventCuts stdtpcrefmultcuts;
250  stdtpcrefmultcuts.SetRefMultMethod(AliFlowEventCuts::kTPConly);
251  AliFlowEventCuts stdv0refmultcuts;
252  stdv0refmultcuts.SetRefMultMethod(AliFlowEventCuts::kV0);
253  AliFlowEventCuts stdspd1refmult;
255  AliFlowEventCuts stdspdrefmult;
257 
258  AliFlowEventSimple* flowevent=NULL;
259  AliFlowEventSimple* floweventin = dynamic_cast<AliFlowEventSimple*>(GetInputData(1));
260  if (!floweventin) flowevent = new AliFlowEvent(fTrackCuts,fTrackCuts);
261  else flowevent = new AliFlowEventSimple(*floweventin);
262 
263  Int_t rpmult = flowevent->GetReferenceMultiplicity();
264  Int_t refmult = fEventCuts->RefMult(event);
265  Int_t refmultv0 = stdv0refmultcuts.RefMult(event);
266  Int_t refmulttpc = stdtpcrefmultcuts.RefMult(event);
267  Int_t refmultspdtr = stdspdrefmult.RefMult(event);
268  Int_t refmultspdcls = stdspd1refmult.RefMult(event);
269 
270  htrackletmultB->Fill(ntracklets); if (passevent) htrackletmultA->Fill(ntracklets);
271  htrackmultB->Fill(rpmult); if (passevent) htrackmultA->Fill(rpmult);
272  hrefmultB->Fill(refmult); if (passevent) hrefmultA->Fill( refmult);
273  hstdv0multB->Fill(refmultv0); if (passevent) hstdv0multA->Fill( refmultv0);
274  hstdtpcmultB->Fill(refmulttpc); if (passevent) hstdtpcmultA->Fill( refmulttpc);
275  hstdspd1clsmultB->Fill(refmultspdcls); if (passevent) hstdspd1clsmultA->Fill( refmultspdcls);
276  hstdspdtrmultB->Fill(refmultspdtr); if (passevent) hstdspdtrmultA->Fill( refmultspdtr);
277 
278  hspdclustersB->Fill(nspdclusters); if (passevent) hspdclustersA->Fill( nspdclusters);
279  const AliVertex* vertex = event->GetPrimaryVertex();
280  Float_t vtxz=0.0;
281  Float_t vtxx=0.0;
282  Float_t vtxy=0.0;
283  if (vertex)
284  {
285  vtxz = vertex->GetZ();
286  vtxx = vertex->GetX();
287  vtxy = vertex->GetY();
288  hprimvtxzB->Fill(vtxz); if (passevent) hprimvtxzA->Fill(vtxz);
289  }
290  const AliVertex* vertextpc = event->GetPrimaryVertexTPC();
291  Float_t vtxTPCx=0.0;
292  Float_t vtxTPCy=0.0;
293  Float_t vtxTPCz=0.0;
294  if (vertextpc)
295  {
296  vtxTPCx = vertextpc->GetX();
297  vtxTPCy = vertextpc->GetY();
298  vtxTPCz = vertextpc->GetZ();
299  hprimvtxzTPCB->Fill(vtxTPCz); if (passevent) hprimvtxzTPCA->Fill(vtxTPCz);
300  }
301  const AliVertex* vertexspd = event->GetPrimaryVertexSPD();
302  Float_t vtxSPDx=0.0;
303  Float_t vtxSPDy=0.0;
304  Float_t vtxSPDz=0.0;
305  if (vertexspd)
306  {
307  vtxSPDx = vertexspd->GetX();
308  vtxSPDy = vertexspd->GetY();
309  vtxSPDz = vertexspd->GetZ();
310  }
311  AliESDVZERO* vzero=event->GetVZEROData();
312  AliESDZDC* zdc=event->GetESDZDC();
313  Float_t mv0a=vzero->GetMTotV0A();
314  Float_t mv0c=vzero->GetMTotV0C();
315  Float_t zdcp1=zdc->GetZDCP1Energy();
316  Float_t zdcn1=zdc->GetZDCN1Energy();
317  Float_t zdcp2=zdc->GetZDCP2Energy();
318  Float_t zdcn2=zdc->GetZDCN2Energy();
319  Float_t zdcpart1=zdc->GetZDCPartSideA();
320  Float_t zdcpart2=zdc->GetZDCPartSideC();
321  Float_t meanpt=0.;
322  Float_t rawmeanpt=0.;
323  Float_t maxpt=0.0;
325  Int_t nselected=0;
326  for (Int_t i=0; i<ntracks; i++)
327  {
328  TObject* obj = fTrackCuts->GetInputObject(i);
329  if (!obj) continue;
330  Bool_t pass = fTrackCuts->IsSelected(obj,i);
331  if (pass) nselected++;
332  Float_t dcaxy=0.0;
333  Float_t dcaz=0.0;
334  Float_t tpcchi2=0.0;
335  Float_t tpcchi2percls=0.0;
336  Int_t ntpccls=0;
337  Int_t nitscls=0;
338  Float_t eta=0.0;
339  Float_t phi=0.0;
340  Float_t pt=0.0;
341  Short_t charge=0;
342  AliESDtrack* track = dynamic_cast<AliESDtrack*>(fTrackCuts->GetTrack());
343  if (track)
344  {
345  track->GetImpactParameters(dcaxy,dcaz);
346  tpcchi2=track->GetTPCchi2();
347  ntpccls=track->GetTPCNcls();
348  eta=track->Eta();
349  phi=track->Phi();
350  pt=track->Pt();
351  if (pt>maxpt) maxpt=pt;
352  charge=track->Charge();
353  rawmeanpt+=pt;
354  if (pass) meanpt+=pt;
355  tpcchi2percls= (ntpccls==0)?0.0:tpcchi2/ntpccls;
356  nitscls = track->GetNcls(0);
357  hITSclsB->Fill(nitscls); if (pass) hITSclsA->Fill( nitscls);
358  hTPCclsB->Fill(ntpccls); if (pass) hTPCclsA->Fill( ntpccls);
359  hTPCchi2B->Fill(tpcchi2percls); if (pass) hTPCchi2A->Fill( tpcchi2percls);
360  hdcaxyB->Fill(dcaxy); if (pass) hdcaxyA->Fill( dcaxy);
361  hdcazB->Fill(dcaz); if (pass) hdcazA->Fill(dcaz);
362  hetatracksB->Fill(eta); if (pass) hetatracksA->Fill(eta);
363  hphitracksB->Fill(phi); if (pass) hphitracksA->Fill(phi);
364  hptyieldB->Fill(pt); if (pass) hptyieldA->Fill(pt);
365  if (charge>0) {hptyieldplusB->Fill(pt); if (pass) hptyieldplusA->Fill(pt);}
366  if (charge<0) {hptyieldnegB->Fill(pt); if (pass) hptyieldnegA->Fill(pt);}
367  hchargesB->Fill(charge); if (pass) hchargesA->Fill(charge);
371  if (fDoCorrelations)
372  {
373  for (Int_t j=i+1; j<ntracks; j++)
374  {
375  TObject* obj2 = fTrackCuts->GetInputObject(j);
376  if (!obj2) continue;
377  Bool_t pass2 = fTrackCuts->IsSelected(obj2,j);
378  AliESDtrack* track2 = dynamic_cast<AliESDtrack*>(fTrackCuts->GetTrack());
379  if (track2)
380  {
381  Double_t dphi = phi-track2->Phi();
382  hphisepB->Fill(dphi); if (pass&&pass2) hphisepA->Fill(dphi);
383  }
384  }
385  }//correlations
386  }
387  }
388  if (nselected!=0) meanpt = meanpt/nselected;
389  if (ntracks!=0) rawmeanpt = rawmeanpt/ntracks;
390 
392  if (fFillNtuple)
393  {
394  Double_t qx = 0.0;
395  Double_t qy = 0.0;
396  Double_t qm = 0.0;
397  Double_t qxp = 0.0;
398  Double_t qyp = 0.0;
399  Double_t qmp = 0.0;
400  Double_t qxn = 0.0;
401  Double_t qyn = 0.0;
402  Double_t qmn = 0.0;
403  Double_t qxa = 0.0;
404  Double_t qya = 0.0;
405  Double_t qma = 0.0;
406  Double_t qxb = 0.0;
407  Double_t qyb = 0.0;
408  Double_t qmb = 0.0;
409 
410  AliFlowVector qvec[2];
411 
412  qvec[0] = flowevent->GetQ(2);
413  qx = qvec[0].X();
414  qy = qvec[0].Y();
415  qm = qvec[0].GetMult();
416  flowevent->TagSubeventsByCharge();
417  flowevent->Get2Qsub(qvec,2);
418  qxp = qvec[0].X();
419  qyp = qvec[0].Y();
420  qmp = qvec[0].GetMult();
421  qxn = qvec[1].X();
422  qyn = qvec[1].Y();
423  qmn = qvec[1].GetMult();
424  flowevent->TagSubeventsInEta(-0.8,-0.1,0.1,0.8);
425  flowevent->Get2Qsub(qvec,2);
426  qxa = qvec[0].X();
427  qya = qvec[0].Y();
428  qma = qvec[0].GetMult();
429  qxb = qvec[1].X();
430  qyb = qvec[1].Y();
431  qmb = qvec[1].GetMult();
432 
433 
434  Float_t x[45];
435  x[0]=meanpt; x[1]=qx; x[2]=qy; x[3]=rpmult; x[4]=refmult; x[5]=(isSelectedEventSelection)?1:0;
436  x[6]=vtxTPCx; x[7]=vtxTPCy; x[8]=vtxTPCz; x[9]=ntrackletsA; x[10]=ntrackletsC;
437  x[11]=mv0a; x[12]=mv0c; x[13]=zdcp1; x[14]=zdcn1; x[15]=zdcp2; x[16]=zdcn2;
438  x[17]=zdcpart1; x[18]=zdcpart2;
439  x[19]=0; if (event->IsTriggerClassFired("CMBAC-B-NOPF-ALL")) x[19]=1;
440  x[20]=0; if (event->IsTriggerClassFired("CMBS2C-B-NOPF-ALL")) x[20]=1;
441  x[21]=0; if (event->IsTriggerClassFired("CMBS2A-B-NOPF-ALL")) x[21]=1;
442  x[22]=0; if (event->IsTriggerClassFired("CMBAC-A-NOPF-ALL")) x[22]=1;
443  x[23]=0; if (event->IsTriggerClassFired("CMBAC-C-NOPF-ALL")) x[23]=1;
444  x[24]=vtxSPDx;
445  x[25]=vtxSPDy;
446  x[26]=vtxSPDz;
447  x[27]=vtxx;
448  x[28]=vtxy;
449  x[29]=vtxz;
450  x[30]=rawmeanpt;
451  x[31]=maxpt;
452  x[32]=qxp;
453  x[33]=qyp;
454  x[34]=qxn;
455  x[35]=qyn;
456  x[36]=qxa;
457  x[37]=qya;
458  x[38]=qxb;
459  x[39]=qyb;
460  x[40]=qm;
461  x[41]=qmp;
462  x[42]=qmn;
463  x[43]=qma;
464  x[44]=qmb;
465  fNtuple->Fill(x);
466  }//if flowevent
467 
468  delete flowevent;
469 }
470 
471 //________________________________________________________________________
473 {
474 
475 }
476 
477 //________________________________________________________________________
479 {
480  //dtor
481  delete fTrackCuts;
482  delete fEventCuts;
483 }
Int_t charge
double Double_t
Definition: External.C:58
virtual AliFlowVector GetQ(Int_t n=2, TList *weightsList=NULL, Bool_t usePhiWeights=kFALSE, Bool_t usePtWeights=kFALSE, Bool_t useEtaWeights=kFALSE)
TObject * GetInputObject(Int_t i)
Double_t GetMult() const
Definition: AliFlowVector.h:46
AliFlowEventCuts * fEventCuts
void SetRefMultMethod(refMultMethod m)
virtual void Terminate(Option_t *)
virtual Bool_t IsSelected(TObject *obj, Int_t id=-666)
virtual void UserCreateOutputObjects()
Int_t GetNumberOfInputObjects() const
int Int_t
Definition: External.C:63
Definition: External.C:204
float Float_t
Definition: External.C:68
Int_t RefMult(AliVEvent *event, AliMCEvent *mcEvent=0x0)
Definition: External.C:212
virtual void Get2Qsub(AliFlowVector *Qarray, Int_t n=2, TList *weightsList=NULL, Bool_t usePhiWeights=kFALSE, Bool_t usePtWeights=kFALSE, Bool_t useEtaWeights=kFALSE)
short Short_t
Definition: External.C:23
virtual void UserExec(Option_t *option)
Int_t GetReferenceMultiplicity() const
void SetEvent(AliVEvent *event, AliMCEvent *mcEvent=NULL)
AliFlowTrackCuts * fTrackCuts
void TagSubeventsInEta(Double_t etaMinA, Double_t etaMaxA, Double_t etaMinB, Double_t etaMaxB)
const char Option_t
Definition: External.C:48
bool Bool_t
Definition: External.C:53
virtual Bool_t IsSelected(TObject *obj, TObject *objmc)
AliVParticle * GetTrack() const
Definition: External.C:196