AliPhysics  608b256 (608b256)
AliFlowEventSimple.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 /*****************************************************************
17  AliFlowEventSimple: A simple event
18  for flow analysis
19 
20  origin: Naomi van der Kolk (kolk@nikhef.nl)
21  Ante Bilandzic (anteb@nikhef.nl)
22  Raimond Snellings (Raimond.Snellings@nikhef.nl)
23  mods: Mikolaj Krzewicki (mikolaj.krzewicki@cern.ch)
24  Redmer A. Bertens (rbertens@cern.ch)
25 *****************************************************************/
26 
27 #include "Riostream.h"
28 #include "TObjArray.h"
29 #include "TFile.h"
30 #include "TList.h"
31 #include "TTree.h"
32 #include "TParticle.h"
33 #include "TMath.h"
34 #include "TH1F.h"
35 #include "TH1D.h"
36 #include "TF1.h"
37 #include "TF2.h"
38 #include "TProfile.h"
39 #include "TParameter.h"
40 #include "TBrowser.h"
41 #include "AliFlowVector.h"
42 #include "AliFlowTrackSimple.h"
43 #include "AliFlowTrackSimpleCuts.h"
44 #include "AliFlowEventSimple.h"
45 #include "TRandom.h"
46 #include <random>
47 
48 using std::cout;
49 using std::endl;
50 using std::cerr;
51 ClassImp(AliFlowEventSimple)
52 
53 //-----------------------------------------------------------------------
55  fTrackCollection(NULL),
56  fReferenceMultiplicity(0),
57  fNumberOfTracks(0),
58  fUseGlauberMCSymmetryPlanes(kFALSE),
59  fUseExternalSymmetryPlanes(kFALSE),
60  fPsi1(0.),
61  fPsi2(0.),
62  fPsi3(0.),
63  fPsi4(0.),
64  fPsi5(0.),
65  fPsi1Psi3(0x0),
66  fPsi2Psi4(0x0),
67  fPsi3Psi5(0x0),
68  fMCReactionPlaneAngle(0.),
69  fMCReactionPlaneAngleIsSet(kFALSE),
70  fAfterBurnerPrecision(0.001),
71  fUserModified(kFALSE),
72  fNumberOfTracksWrap(NULL),
73  fNumberOfRPsWrap(NULL),
74  fNumberOfPOIsWrap(NULL),
75  fMCReactionPlaneAngleWrap(NULL),
76  fShuffledIndexes(NULL),
77  fShuffleTracks(kFALSE),
78  fMothersCollection(NULL),
79  fCentrality(-1.),
80  fCentralityCL1(-1.),
81  fNITSCL1(-1.),
82  fCentralityTRK(-1.),
83  fRun(-1),
84  fZNCQ0(0.),
85  fZNAQ0(0.),
86  fZNCM(0.),
87  fZNAM(0.),
88  fZPCM(0.),
89  fZPAM(0.),
90  fAbsOrbit(0),
91  fNumberOfPOItypes(2),
92  fNumberOfPOIs(NULL)
93 {
94  fZNCQ = AliFlowVector();
95  fZNAQ = AliFlowVector();
96  for(Int_t i(0); i < 3; i++) {
97  fVtxPos[i] = 0.;
98  }
99  for(Int_t i=0; i < 4; i++) {
100  fV0C[i] = AliFlowVector();
101  fV0A[i] = AliFlowVector();
102  }
103  cout << "AliFlowEventSimple: Default constructor to be used only by root for io" << endl;
104 }
105 
106 //-----------------------------------------------------------------------
109  TF1* ptDist,
112  Double_t etaMin,
113  Double_t etaMax):
114  fTrackCollection(new TObjArray(n)),
115  fReferenceMultiplicity(0),
116  fNumberOfTracks(0),
117  fUseGlauberMCSymmetryPlanes(kFALSE),
118  fUseExternalSymmetryPlanes(kFALSE),
119  fPsi1(0.),
120  fPsi2(0.),
121  fPsi3(0.),
122  fPsi4(0.),
123  fPsi5(0.),
124  fPsi1Psi3(0x0),
125  fPsi2Psi4(0x0),
126  fPsi3Psi5(0x0),
127  fMCReactionPlaneAngle(0.),
128  fMCReactionPlaneAngleIsSet(kFALSE),
129  fAfterBurnerPrecision(0.001),
130  fUserModified(kFALSE),
131  fNumberOfTracksWrap(NULL),
132  fNumberOfRPsWrap(NULL),
133  fNumberOfPOIsWrap(NULL),
134  fMCReactionPlaneAngleWrap(NULL),
135  fShuffledIndexes(NULL),
136  fShuffleTracks(kFALSE),
137  fMothersCollection(new TObjArray()),
138  fCentrality(-1.),
139  fCentralityCL1(-1.),
140  fNITSCL1(-1.),
141  fCentralityTRK(-1.),
142  fRun(-1),
143  fZNCQ0(0.),
144  fZNAQ0(0.),
145  fZNCM(0.),
146  fZNAM(0.),
147  fZPCM(0.),
148  fZPAM(0.),
149  fAbsOrbit(0),
150  fNumberOfPOItypes(2),
151  fNumberOfPOIs(new Int_t[fNumberOfPOItypes])
152 {
153  //ctor
154  // if second argument is set to AliFlowEventSimple::kGenerate
155  // it generates n random tracks with given Pt distribution
156  // (a sane default is provided), phi and eta are uniform
157 
158  if (method==kGenerate)
159  Generate(n,ptDist,phiMin,phiMax,etaMin,etaMax);
160 
161  fZNCQ = AliFlowVector();
162  fZNAQ = AliFlowVector();
163  for(Int_t i(0); i < 3; i++) {
164  fVtxPos[i] = 0.;
165  }
166  for(Int_t i=0; i < 4; i++) {
167  fV0C[i] = AliFlowVector();
168  fV0A[i] = AliFlowVector();
169  }
170 }
171 
172 //-----------------------------------------------------------------------
174  TObject(anEvent),
175  fTrackCollection((TObjArray*)(anEvent.fTrackCollection)->Clone()),
180  fPsi1(anEvent.fPsi1),
181  fPsi2(anEvent.fPsi2),
182  fPsi3(anEvent.fPsi3),
183  fPsi4(anEvent.fPsi4),
184  fPsi5(anEvent.fPsi5),
185  fPsi1Psi3(anEvent.fPsi1Psi3),
186  fPsi2Psi4(anEvent.fPsi2Psi4),
187  fPsi3Psi5(anEvent.fPsi3Psi5),
191  fUserModified(anEvent.fUserModified),
196  fShuffledIndexes(NULL),
199  fCentrality(anEvent.fCentrality),
201  fNITSCL1(anEvent.fNITSCL1),
203  fRun(anEvent.fRun),
204  fZNCQ(anEvent.fZNCQ),
205  fZNAQ(anEvent.fZNAQ),
206  fZNCQ0(anEvent.fZNCQ0),
207  fZNAQ0(anEvent.fZNAQ0),
208  fZNCM(anEvent.fZNCM),
209  fZNAM(anEvent.fZNAM),
210  fZPCM(anEvent.fZPCM),
211  fZPAM(anEvent.fZPAM),
212  fAbsOrbit(anEvent.fAbsOrbit),
215 {
216  //copy constructor
217  memcpy(fNumberOfPOIs,anEvent.fNumberOfPOIs,fNumberOfPOItypes*sizeof(Int_t));
218  for(Int_t i(0); i < 3; i++) {
219  fVtxPos[i] = anEvent.fVtxPos[i];
220  }
221  for(Int_t i=0; i < 4; i++) {
222  fV0C[i] = anEvent.fV0C[i];
223  fV0A[i] = anEvent.fV0A[i];
224  }
225 }
226 
227 //-----------------------------------------------------------------------
228 void AliFlowEventSimple::SetNumberOfPOIs( Int_t numberOfPOIs, Int_t poiType)
229 {
230  //set the number of poi classes, resize the array if larger is needed
231  //never shrink the array
232  //never decrease the stored number
233  if (poiType>=fNumberOfPOItypes)
234  {
235  Int_t n = poiType+1;
236  Int_t* tmp = new Int_t[n];
237  for (Int_t j=0; j<n; j++) { tmp[j]=0; }
238  memcpy(tmp,fNumberOfPOIs,fNumberOfPOItypes*sizeof(Int_t));
239  delete [] fNumberOfPOIs;
240  fNumberOfPOIs = tmp;
241  fNumberOfPOItypes = n;
242  }
243 
244  fNumberOfPOIs[poiType] = numberOfPOIs;
245 }
246 
247 //-----------------------------------------------------------------------
249 {
250 
251  if (poiType>=fNumberOfPOItypes) SetNumberOfPOIs(0,poiType);
252  fNumberOfPOIs[poiType]++;
253 }
254 
255 //-----------------------------------------------------------------------
257 {
258  //assignment operator
259  if (&anEvent==this) return *this; //check self-assignment
260  if (fTrackCollection) fTrackCollection->Delete();
261  delete fTrackCollection;
262  fTrackCollection = (TObjArray*)(anEvent.fTrackCollection)->Clone(); //deep copy
266  delete [] fNumberOfPOIs;
268  memcpy(fNumberOfPOIs,anEvent.fNumberOfPOIs,fNumberOfPOItypes*sizeof(Int_t));
271  fPsi1 = anEvent.fPsi1;
272  fPsi2 = anEvent.fPsi2;
273  fPsi3 = anEvent.fPsi3;
274  fPsi4 = anEvent.fPsi4;
275  fPsi5 = anEvent.fPsi5;
276  fPsi1Psi3 = anEvent.fPsi1Psi3;
277  fPsi2Psi4 = anEvent.fPsi2Psi4;
278  fPsi3Psi5 = anEvent.fPsi3Psi5;
287  fShuffleTracks = anEvent.fShuffleTracks;
288  fCentrality = anEvent.fCentrality;
289  fCentralityCL1 = anEvent.fCentralityCL1;
290  fNITSCL1 = anEvent.fNITSCL1;
291  fCentralityTRK = anEvent.fCentralityTRK;
292  fRun = anEvent.fRun;
293  fZNCQ = anEvent.fZNCQ;
294  fZNAQ = anEvent.fZNAQ;
295  fZNCQ0 = anEvent.fZNCQ0;
296  fZNAQ0 = anEvent.fZNAQ0;
297  fZNCM = anEvent.fZNCM;
298  fZNAM = anEvent.fZNAM;
299  fZPCM = anEvent.fZPCM;
300  fZPAM = anEvent.fZPAM;
301  fAbsOrbit = anEvent.fAbsOrbit;
302  for(Int_t i(0); i < 3; i++) {
303  fVtxPos[i] = anEvent.fVtxPos[i];
304  }
305  for(Int_t i=0; i < 4; i++) {
306  fV0C[i] = anEvent.fV0C[i];
307  fV0A[i] = anEvent.fV0A[i];
308  }
309  delete [] fShuffledIndexes;
310  return *this;
311 }
312 
313 //-----------------------------------------------------------------------
315 {
316  //destructor
317  if (fTrackCollection) fTrackCollection->Delete();
318  delete fTrackCollection;
319  delete fNumberOfTracksWrap;
320  delete fNumberOfRPsWrap;
321  delete fNumberOfPOIsWrap;
323  delete fShuffledIndexes;
324  delete fMothersCollection;
325  delete [] fNumberOfPOIs;
326 }
327 
328 //-----------------------------------------------------------------------
330  TF1 *gPsi2Psi4,
331  TF1 *gPsi3Psi5) {
332  //Use symmetry planes, setup correlations between different Psi_n
334 
335  //Correlations between Psi_1 and Psi_3
336  if(gPsi1Psi3) fPsi1Psi3 = gPsi1Psi3;
337  else {
338  fPsi1Psi3 = new TF1("fPsi1Psi3","[0]*x+[1]",0.,2.*TMath::Pi());
339  fPsi1Psi3->SetParameter(0,1.);
340  fPsi1Psi3->SetParameter(1,0.);
341  }
342 
343  //Correlations between Psi_2 and Psi_4
344  if(gPsi2Psi4) fPsi2Psi4 = gPsi2Psi4;
345  else {
346  fPsi2Psi4 = new TF1("fPsi2Psi4","[0]*x+[1]",0.,2.*TMath::Pi());
347  fPsi2Psi4->SetParameter(0,1.);
348  fPsi2Psi4->SetParameter(1,0.);
349  }
350 
351  //Correlations between Psi_3 and Psi_5
352  if(gPsi3Psi5) fPsi3Psi5 = gPsi3Psi5;
353  else {
354  fPsi3Psi5 = new TF1("fPsi3Psi5","[0]*x+[1]",0.,2.*TMath::Pi());
355  fPsi3Psi5->SetParameter(0,1.);
356  fPsi3Psi5->SetParameter(1,0.);
357  }
358 }
359 
360 //-----------------------------------------------------------------------
362  TF1* ptDist,
365  Double_t etaMin,
366  Double_t etaMax)
367 {
368  //generate nParticles random tracks uniform in phi and eta
369  //according to the specified pt distribution
370  if (!ptDist)
371  {
372  static TF1 ptdistribution("ptSpectra","x*TMath::Exp(-pow(0.13957*0.13957+x*x,0.5)/0.4)",0.1,10.);
373  ptDist=&ptdistribution;
374  }
375 
376  for (Int_t i=0; i<nParticles; i++)
377  {
378  AliFlowTrackSimple* track = new AliFlowTrackSimple();
379  track->SetPhi( gRandom->Uniform(phiMin,phiMax) );
380  track->SetEta( gRandom->Uniform(etaMin,etaMax) );
381  track->SetPt( ptDist->GetRandom() );
382  track->SetCharge( (gRandom->Uniform()-0.5<0)?-1:1 );
383  AddTrack(track);
384  }
386  Double_t betaParameter = gRandom->Gaus(0.,1.3);
387  fPsi1Psi3->SetParameter(1,betaParameter);
388 
389  betaParameter = gRandom->Gaus(0.,0.9);
390  fPsi2Psi4->SetParameter(1,betaParameter);
391 
392  betaParameter = gRandom->Gaus(0.,1.5);
393  fPsi3Psi5->SetParameter(1,betaParameter);
394 
395  fPsi1 = gRandom->Uniform(2.*TMath::Pi());
396  fPsi2 = gRandom->Uniform(2.*TMath::Pi());
397  fPsi3 = fPsi1Psi3->Eval(fPsi1);
398  if(fPsi3 < 0) fPsi3 += 2.*TMath::Pi();
399  else if(fPsi3 > 2.*TMath::Pi()) fPsi3 -= 2.*TMath::Pi();
400  fPsi4 = fPsi2Psi4->Eval(fPsi2);
401  if(fPsi4 < 0) fPsi4 += 2.*TMath::Pi();
402  else if(fPsi4 > 2.*TMath::Pi()) fPsi4 -= 2.*TMath::Pi();
403  fPsi5 = fPsi3Psi5->Eval(fPsi3);
404  if(fPsi5 < 0) fPsi5 += 2.*TMath::Pi();
405  else if(fPsi5 > 2.*TMath::Pi()) fPsi5 -= 2.*TMath::Pi();
406 
409  }
410  else {
411  fMCReactionPlaneAngle=gRandom->Uniform(0.0,TMath::TwoPi());
413  }
414  SetUserModified();
415 }
416 
417 //-----------------------------------------------------------------------
419 {
420  //get track i from collection
421  if (i>=fNumberOfTracks) return NULL;
422  Int_t trackIndex=i;
423  //if asked use the shuffled index
424  if (fShuffleTracks)
425  {
427  trackIndex=fShuffledIndexes[i];
428  }
429  AliFlowTrackSimple* pTrack = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(trackIndex)) ;
430  return pTrack;
431 }
432 
433 //-----------------------------------------------------------------------
435 {
436  //shuffle track indexes
437  if (!fShuffledIndexes)
438  {
439  //initialize the table with shuffled indexes
441  for (Int_t j=0; j<fNumberOfTracks; j++) { fShuffledIndexes[j]=j; }
442  }
443  //shuffle
444  std::random_device rd;
445  std::default_random_engine engine{rd()};
446  std::shuffle(&fShuffledIndexes[0], &fShuffledIndexes[fNumberOfTracks],engine);
447  Printf("Tracks shuffled! tracks: %i",fNumberOfTracks);
448 }
449 
450 //-----------------------------------------------------------------------
452 {
453  //add a track, delete the old one if necessary
454  if (fNumberOfTracks < fTrackCollection->GetEntriesFast())
455  {
457  delete o;
458  }
459  fTrackCollection->AddAtAndExpand(track,fNumberOfTracks);
460  if (track->GetNDaughters()>0)
461  {
462  //if there track has daughters cache in the collection of mothers
463  fMothersCollection->Add(track);
464  }
465  TrackAdded();
466 }
467 
468 //-----------------------------------------------------------------------
470 {
471  //book keeping after a new track has been added
472  fNumberOfTracks++;
473  if (fShuffledIndexes)
474  {
475  delete [] fShuffledIndexes;
476  fShuffledIndexes=NULL;
477  }
478 }
479 
480 //-----------------------------------------------------------------------
482 {
484  if( !t ) { // If there was no track at the end of the list then create a new track
485  t=new AliFlowTrackSimple();
486  }
487 
488  return t;
489 }
490 
491 //-----------------------------------------------------------------------
493  TList *weightsList,
494  Bool_t usePhiWeights,
495  Bool_t usePtWeights,
496  Bool_t useEtaWeights )
497 {
498  // calculate Q-vector in harmonic n without weights (default harmonic n=2)
499  Double_t dQX = 0.;
500  Double_t dQY = 0.;
501  AliFlowVector vQ;
502  vQ.Set(0.,0.);
503 
504  Int_t iOrder = n;
505  Double_t sumOfWeights = 0.;
506  Double_t dPhi = 0.;
507  Double_t dPt = 0.;
508  Double_t dEta = 0.;
509  Double_t dWeight = 1.;
510 
511  AliFlowTrackSimple* pTrack = NULL;
512 
513  Int_t nBinsPhi = 0;
514  Double_t dBinWidthPt = 0.;
515  Double_t dPtMin = 0.;
516  Double_t dBinWidthEta = 0.;
517  Double_t dEtaMin = 0.;
518 
519  Double_t wPhi = 1.; // weight Phi
520  Double_t wPt = 1.; // weight Pt
521  Double_t wEta = 1.; // weight Eta
522 
523  TH1F *phiWeights = NULL;
524  TH1D *ptWeights = NULL;
525  TH1D *etaWeights = NULL;
526 
527  if(weightsList)
528  {
529  if(usePhiWeights)
530  {
531  phiWeights = dynamic_cast<TH1F *>(weightsList->FindObject("phi_weights"));
532  if(phiWeights) nBinsPhi = phiWeights->GetNbinsX();
533  }
534  if(usePtWeights)
535  {
536  ptWeights = dynamic_cast<TH1D *>(weightsList->FindObject("pt_weights"));
537  if(ptWeights)
538  {
539  dBinWidthPt = ptWeights->GetBinWidth(1); // assuming that all bins have the same width
540  dPtMin = (ptWeights->GetXaxis())->GetXmin();
541  }
542  }
543  if(useEtaWeights)
544  {
545  etaWeights = dynamic_cast<TH1D *>(weightsList->FindObject("eta_weights"));
546  if(etaWeights)
547  {
548  dBinWidthEta = etaWeights->GetBinWidth(1); // assuming that all bins have the same width
549  dEtaMin = (etaWeights->GetXaxis())->GetXmin();
550  }
551  }
552  } // end of if(weightsList)
553 
554  // loop over tracks
555  for(Int_t i=0; i<fNumberOfTracks; i++)
556  {
557  pTrack = (AliFlowTrackSimple*)fTrackCollection->At(i);
558  if(pTrack)
559  {
560  if(pTrack->InRPSelection())
561  {
562  dPhi = pTrack->Phi();
563  dPt = pTrack->Pt();
564  dEta = pTrack->Eta();
565  dWeight = pTrack->Weight();
566 
567  // determine Phi weight: (to be improved, I should here only access it + the treatment of gaps in the if statement)
568  if(phiWeights && nBinsPhi)
569  {
570  wPhi = phiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*nBinsPhi/TMath::TwoPi())));
571  }
572  // determine v'(pt) weight:
573  if(ptWeights && dBinWidthPt)
574  {
575  wPt=ptWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-dPtMin)/dBinWidthPt)));
576  }
577  // determine v'(eta) weight:
578  if(etaWeights && dBinWidthEta)
579  {
580  wEta=etaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-dEtaMin)/dBinWidthEta)));
581  }
582 
583  // building up the weighted Q-vector:
584  dQX += dWeight*wPhi*wPt*wEta*TMath::Cos(iOrder*dPhi);
585  dQY += dWeight*wPhi*wPt*wEta*TMath::Sin(iOrder*dPhi);
586 
587  // weighted multiplicity:
588  sumOfWeights += dWeight*wPhi*wPt*wEta;
589 
590  } // end of if (pTrack->InRPSelection())
591  } // end of if (pTrack)
592  else
593  {
594  cerr << "no particle!!!"<<endl;
595  }
596  } // loop over particles
597 
598  vQ.Set(dQX,dQY);
599  vQ.SetMult(sumOfWeights);
600  vQ.SetHarmonic(iOrder);
602  vQ.SetSubeventNumber(-1);
603 
604  return vQ;
605 
606 }
607 
608 //-----------------------------------------------------------------------
610  Int_t n,
611  TList *weightsList,
612  Bool_t usePhiWeights,
613  Bool_t usePtWeights,
614  Bool_t useEtaWeights )
615 {
616 
617  // calculate Q-vector in harmonic n without weights (default harmonic n=2)
618  Double_t dQX = 0.;
619  Double_t dQY = 0.;
620 
621  Int_t iOrder = n;
622  Double_t sumOfWeights = 0.;
623  Double_t dPhi = 0.;
624  Double_t dPt = 0.;
625  Double_t dEta = 0.;
626  Double_t dWeight = 1.;
627 
628  AliFlowTrackSimple* pTrack = NULL;
629 
630  Int_t iNbinsPhiSub0 = 0;
631  Int_t iNbinsPhiSub1 = 0;
632  Double_t dBinWidthPt = 0.;
633  Double_t dPtMin = 0.;
634  Double_t dBinWidthEta= 0.;
635  Double_t dEtaMin = 0.;
636 
637  Double_t dWphi = 1.; // weight Phi
638  Double_t dWpt = 1.; // weight Pt
639  Double_t dWeta = 1.; // weight Eta
640 
641  TH1F* phiWeightsSub0 = NULL;
642  TH1F* phiWeightsSub1 = NULL;
643  TH1D* ptWeights = NULL;
644  TH1D* etaWeights = NULL;
645 
646  if(weightsList)
647  {
648  if(usePhiWeights)
649  {
650  phiWeightsSub0 = dynamic_cast<TH1F *>(weightsList->FindObject("phi_weights_sub0"));
651  if(phiWeightsSub0) {
652  iNbinsPhiSub0 = phiWeightsSub0->GetNbinsX();
653  }
654  phiWeightsSub1 = dynamic_cast<TH1F *>(weightsList->FindObject("phi_weights_sub1"));
655  if(phiWeightsSub1) {
656  iNbinsPhiSub1 = phiWeightsSub1->GetNbinsX();
657  }
658  }
659  if(usePtWeights)
660  {
661  ptWeights = dynamic_cast<TH1D *>(weightsList->FindObject("pt_weights"));
662  if(ptWeights)
663  {
664  dBinWidthPt = ptWeights->GetBinWidth(1); // assuming that all bins have the same width
665  dPtMin = (ptWeights->GetXaxis())->GetXmin();
666  }
667  }
668  if(useEtaWeights)
669  {
670  etaWeights = dynamic_cast<TH1D *>(weightsList->FindObject("eta_weights"));
671  if(etaWeights)
672  {
673  dBinWidthEta = etaWeights->GetBinWidth(1); // assuming that all bins have the same width
674  dEtaMin = (etaWeights->GetXaxis())->GetXmin();
675  }
676  }
677  } // end of if(weightsList)
678 
679  //loop over the two subevents
680  for (Int_t s=0; s<2; s++)
681  {
682  // loop over tracks
683  for(Int_t i=0; i<fNumberOfTracks; i++)
684  {
685  pTrack = (AliFlowTrackSimple*)fTrackCollection->At(i);
686  if(!pTrack)
687  {
688  cerr << "no particle!!!"<<endl;
689  continue;
690  }
691  if(pTrack->InRPSelection() && (pTrack->InSubevent(s)))
692  {
693  dPhi = pTrack->Phi();
694  dPt = pTrack->Pt();
695  dEta = pTrack->Eta();
696  dWeight = pTrack->Weight();
697 
698  // determine Phi weight: (to be improved, I should here only access it + the treatment of gaps in the if statement)
699  //subevent 0
700  if(s == 0) {
701  if(phiWeightsSub0 && iNbinsPhiSub0) {
702  Int_t phiBin = 1+(Int_t)(TMath::Floor(dPhi*iNbinsPhiSub0/TMath::TwoPi()));
703  //use the phi value at the center of the bin
704  dPhi = phiWeightsSub0->GetBinCenter(phiBin);
705  dWphi = phiWeightsSub0->GetBinContent(phiBin);
706  }
707  }
708  //subevent 1
709  else if (s == 1) {
710  if(phiWeightsSub1 && iNbinsPhiSub1) {
711  Int_t phiBin = 1+(Int_t)(TMath::Floor(dPhi*iNbinsPhiSub1/TMath::TwoPi()));
712  //use the phi value at the center of the bin
713  dPhi = phiWeightsSub1->GetBinCenter(phiBin);
714  dWphi = phiWeightsSub1->GetBinContent(phiBin);
715  }
716  }
717 
718  // determine v'(pt) weight:
719  if(ptWeights && dBinWidthPt)
720  {
721  dWpt=ptWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-dPtMin)/dBinWidthPt)));
722  }
723 
724  // determine v'(eta) weight:
725  if(etaWeights && dBinWidthEta)
726  {
727  dWeta=etaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-dEtaMin)/dBinWidthEta)));
728  }
729 
730  // building up the weighted Q-vector:
731  dQX += dWeight*dWphi*dWpt*dWeta*TMath::Cos(iOrder*dPhi);
732  dQY += dWeight*dWphi*dWpt*dWeta*TMath::Sin(iOrder*dPhi);
733 
734  // weighted multiplicity:
735  sumOfWeights+=dWeight*dWphi*dWpt*dWeta;
736 
737  } // end of if (pTrack->InRPSelection())
738  } // loop over particles
739 
740  Qarray[s].Set(dQX,dQY);
741  Qarray[s].SetMult(sumOfWeights);
742  Qarray[s].SetHarmonic(iOrder);
744  Qarray[s].SetSubeventNumber(s);
745 
746  //reset
747  sumOfWeights = 0.;
748  dQX = 0.;
749  dQY = 0.;
750  }
751 
752 }
753 
754 //------------------------------------------------------------------------------
755 
757 {
758  Qarray[0] = fZNCQ;
759  Qarray[1] = fZNAQ;
760 }
761 
762 //------------------------------------------------------------------------------
763 
765 {
766  fZNCQ = AliFlowVector(QVC[0],QVC[1],MC,1);
767  fZNAQ = AliFlowVector(QVA[0],QVA[1],MA,1);
768 }
769 
770 //------------------------------------------------------------------------------
771 
773 {
774  if(har>0 && har<5) {
775  Qarray[0] = fV0C[har-1];
776  Qarray[1] = fV0A[har-1];
777  } else {
778  printf("WARNING: harmonic %d not available \n",har);
779  }
780 }
781 
782 //------------------------------------------------------------------------------
783 
785 {
786  if(har>0 && har<5) {
787  fV0C[har-1] = AliFlowVector(QVCx,QVCy,MC,har);
788  fV0A[har-1] = AliFlowVector(QVAx,QVAy,MA,har);
789  }
790 }
791 
792 //------------------------------------------------------------------------------
793 
795 {
796  pos[0] = fVtxPos[0];
797  pos[1] = fVtxPos[1];
798  pos[2] = fVtxPos[2];
799 }
800 
801 //------------------------------------------------------------------------------
802 
804 {
805  fVtxPos[0] = pos[0];
806  fVtxPos[1] = pos[1];
807  fVtxPos[2] = pos[2];
808 }
809 //------------------------------------------------------------------------------
810 
812 {
813  // -*-*-*-*-*Print some global quantities for this histogram collection class *-*-*-*-*-*-*-*
814  // ===============================================
815  // printf( "TH1.Print Name = %s, Entries= %d, Total sum= %g\n",GetName(),Int_t(fEntries),GetSumOfWeights());
816  printf( "Class.Print Name = %s, #tracks= %d, Number of RPs= %d, Number of POIs = %d, MC EventPlaneAngle= %f\n",
818 
819  TString optionstr(option);
820  if (!optionstr.Contains("all")) return;
821  if (fTrackCollection)
822  {
823  fTrackCollection->Print(option);
824  }
825  else
826  {
827  printf( "Empty track collection \n");
828  }
829 }
830 
831 //-----------------------------------------------------------------------
832 void AliFlowEventSimple::Browse(TBrowser *b)
833 {
834  //browse in TBrowser
835  if (!b) return;
836  if (!fNumberOfTracksWrap)
837  {
838  fNumberOfTracksWrap = new TParameter<int>("fNumberOfTracks", fNumberOfTracks);
839  b->Add(fNumberOfTracksWrap);
840  }
841  if (!fNumberOfRPsWrap)
842  {
843  fNumberOfRPsWrap = new TParameter<int>("fNumberOfRPs", GetNumberOfRPs());
844  b->Add(fNumberOfRPsWrap);
845  }
846  if (!fNumberOfPOIsWrap)
847  {
848  fNumberOfPOIsWrap = new TParameter<int>("fNumberOfPOIs", GetNumberOfPOIs());
849  b->Add(fNumberOfPOIsWrap);
850  }
852  {
853  fMCReactionPlaneAngleWrap = new TParameter<double>(" fMCReactionPlaneAngle", fMCReactionPlaneAngle);
854  b->Add( fMCReactionPlaneAngleWrap);
855  }
856  if (fTrackCollection) b->Add(fTrackCollection,"AliFlowTracksSimple");
857 }
858 
859 //-----------------------------------------------------------------------
861  const AliFlowTrackSimpleCuts* rpCuts,
862  const AliFlowTrackSimpleCuts* poiCuts):
863  fTrackCollection(NULL),
865  fNumberOfTracks(0),
868  fPsi1(0.),
869  fPsi2(0.),
870  fPsi3(0.),
871  fPsi4(0.),
872  fPsi5(0.),
873  fPsi1Psi3(0x0),
874  fPsi2Psi4(0x0),
875  fPsi3Psi5(0x0),
878  fAfterBurnerPrecision(0.001),
879  fUserModified(kFALSE),
880  fNumberOfTracksWrap(NULL),
881  fNumberOfRPsWrap(NULL),
882  fNumberOfPOIsWrap(NULL),
884  fShuffledIndexes(NULL),
885  fShuffleTracks(kFALSE),
887  fCentrality(-1.),
888  fCentralityCL1(-1.),
889  fNITSCL1(-1.),
890  fCentralityTRK(-1.),
891  fRun(-1),
892  fZNCQ0(0.),
893  fZNAQ0(0.),
894  fZNCM(0.),
895  fZNAM(0.),
896  fZPCM(0.),
897  fZPAM(0.),
898  fAbsOrbit(0),
901 {
902  //constructor, fills the event from a TTree of kinematic.root files
903  //applies RP and POI cuts, tags the tracks
904 
905  Int_t numberOfInputTracks = inputTree->GetEntries() ;
906  fTrackCollection = new TObjArray(numberOfInputTracks/2);
907 
908  TParticle* pParticle = new TParticle();
909  inputTree->SetBranchAddress("Particles",&pParticle);
910 
911  for (Int_t i=0; i<numberOfInputTracks; i++)
912  {
913  inputTree->GetEntry(i); //get input particle
914 
915  if (!pParticle) continue; //no particle
916  if (!pParticle->IsPrimary()) continue;
917 
918  Bool_t rpOK = (rpCuts->PassesCuts(pParticle)>0);
919  Bool_t poiOK = poiCuts->PassesCuts(pParticle);
920  Int_t poiType = poiCuts->GetPOItype();
921 
922  if (rpOK || poiOK)
923  {
924  AliFlowTrackSimple* pTrack = new AliFlowTrackSimple(pParticle);
925 
926  //marking the particles used for int. flow:
927  if(rpOK)
928  {
929  pTrack->TagRP(kTRUE);
931  cout<<"numberOfRPs = "<<fNumberOfPOIs[0]<<endl;
932  }
933  //marking the particles used for diff. flow:
934  if(poiOK)
935  {
936  pTrack->Tag(poiType);
937  IncrementNumberOfPOIs(poiType);
938  printf("fNumberOfPOIs[%i] = %i",poiType,fNumberOfPOIs[poiType]);
939  }
940  //adding a particles which were used either for int. or diff. flow to the list
941  AddTrack(pTrack);
942  }
943  }//for i
944  delete pParticle;
945 
946  fZNCQ = AliFlowVector();
947  fZNAQ = AliFlowVector();
948  for(Int_t i(0); i < 3; i++) {
949  fVtxPos[i] = 0.;
950  }
951  for(Int_t i=0; i < 4; i++) {
952  fV0C[i] = AliFlowVector();
953  fV0A[i] = AliFlowVector();
954  }
955 }
956 
957 //_____________________________________________________________________________
959 {
960  //clone every track n times to add non-flow
961  if (n<=0) return; //no use to clone stuff zero or less times
962  Int_t ntracks = fNumberOfTracks;
963  fTrackCollection->Expand((n+1)*fNumberOfTracks);
964  for (Int_t i=0; i<n; i++)
965  {
966  for (Int_t itrack=0; itrack<ntracks; itrack++)
967  {
968  AliFlowTrackSimple* track = dynamic_cast<AliFlowTrackSimple*>(fTrackCollection->At(itrack));
969  if (!track) continue;
970  AddTrack(static_cast<AliFlowTrackSimple*>(track->Clone()));
971  }
972  }
973  SetUserModified();
974 }
975 
976 //_____________________________________________________________________________
978 {
979  //smear pt of all tracks by gaussian with sigma=res
980  for (Int_t i=0; i<fNumberOfTracks; i++)
981  {
982  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
983  if (track) track->ResolutionPt(res);
984  }
985  SetUserModified();
986 }
987 
988 //_____________________________________________________________________________
990  Double_t etaMaxA,
991  Double_t etaMinB,
992  Double_t etaMaxB )
993 {
994  //Flag two subevents in given eta ranges
995  for (Int_t i=0; i<fNumberOfTracks; i++)
996  {
997  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
998  if (!track) continue;
999  track->ResetSubEventTags();
1000  Double_t eta=track->Eta();
1001  if (eta >= etaMinA && eta <= etaMaxA) track->SetForSubevent(0);
1002  if (eta >= etaMinB && eta <= etaMaxB) track->SetForSubevent(1);
1003  }
1004 }
1005 
1006 //_____________________________________________________________________________
1008 {
1009  //Flag two subevents in given eta ranges
1010  for (Int_t i=0; i<fNumberOfTracks; i++)
1011  {
1012  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1013  if (!track) continue;
1014  track->ResetSubEventTags();
1015  Int_t charge=track->Charge();
1016  if (charge<0) track->SetForSubevent(0);
1017  if (charge>0) track->SetForSubevent(1);
1018  }
1019 }
1020 
1021 //_____________________________________________________________________________
1023 {
1024  //add v2 to all tracks wrt the reaction plane angle
1025  for (Int_t i=0; i<fNumberOfTracks; i++)
1026  {
1027  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1028  if (track) {
1030  track->AddV1(v1, fPsi1, fAfterBurnerPrecision);
1031  else
1033  }
1034  }
1035  SetUserModified();
1036 }
1037 
1038 //_____________________________________________________________________________
1040 {
1041  //add v2 to all tracks wrt the reaction plane angle
1042  for (Int_t i=0; i<fNumberOfTracks; i++)
1043  {
1044  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1045  if (track) {
1047  track->AddV2(v2, fPsi2, fAfterBurnerPrecision);
1048  else
1050  }
1051  }
1052  SetUserModified();
1053 }
1054 
1055 //_____________________________________________________________________________
1057 {
1058  //add v3 to all tracks wrt the reaction plane angle
1059  for (Int_t i=0; i<fNumberOfTracks; i++)
1060  {
1061  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1062  if(track) {
1064  track->AddV3(v3, fPsi3, fAfterBurnerPrecision);
1065  else
1067  }
1068  }
1069  SetUserModified();
1070 }
1071 
1072 //_____________________________________________________________________________
1074 {
1075  //add v4 to all tracks wrt the reaction plane angle
1076  for (Int_t i=0; i<fNumberOfTracks; i++)
1077  {
1078  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1079  if(track) {
1081  track->AddV4(v4, fPsi4, fAfterBurnerPrecision);
1082  else
1084  }
1085  }
1086  SetUserModified();
1087 }
1088 
1089 //_____________________________________________________________________________
1091 {
1092  //add v4 to all tracks wrt the reaction plane angle
1093  for (Int_t i=0; i<fNumberOfTracks; i++)
1094  {
1095  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1096  if(track) {
1098  track->AddV5(v5, fPsi5, fAfterBurnerPrecision);
1099  else
1101  }
1102  }
1103  SetUserModified();
1104 }
1105 
1106 //_____________________________________________________________________________
1108  Double_t rp1, Double_t rp2, Double_t rp3, Double_t rp4, Double_t rp5 )
1109 {
1110  //add flow to all tracks wrt the reaction plane angle, for all harmonic separate angle
1111  for (Int_t i=0; i<fNumberOfTracks; i++)
1112  {
1113  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1114  if (track) track->AddFlow(v1,v2,v3,v4,v5,rp1,rp2,rp3,rp4,rp5,fAfterBurnerPrecision);
1115  }
1116  SetUserModified();
1117 }
1118 
1119 //_____________________________________________________________________________
1121 {
1122  //add flow to all tracks wrt the reaction plane angle
1123  for (Int_t i=0; i<fNumberOfTracks; i++)
1124  {
1125  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1126  if (track) track->AddFlow(v1,v2,v3,v4,v5,fMCReactionPlaneAngle, fAfterBurnerPrecision);
1127  }
1128  SetUserModified();
1129 }
1130 
1131 //_____________________________________________________________________________
1132 void AliFlowEventSimple::AddV2( TF1* ptDepV2 )
1133 {
1134  //add v2 to all tracks wrt the reaction plane angle
1135  for (Int_t i=0; i<fNumberOfTracks; i++)
1136  {
1137  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1138  if (!track) continue;
1139  Double_t v2 = ptDepV2->Eval(track->Pt());
1141  }
1142  SetUserModified();
1143 }
1144 
1145 //_____________________________________________________________________________
1146 void AliFlowEventSimple::AddV2( TF2* ptEtaDepV2 )
1147 {
1148  //add v2 to all tracks wrt the reaction plane angle
1149  for (Int_t i=0; i<fNumberOfTracks; i++)
1150  {
1151  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1152  if (!track) continue;
1153  Double_t v2 = ptEtaDepV2->Eval(track->Pt(), track->Eta());
1155  }
1156  SetUserModified();
1157 }
1158 
1159 //_____________________________________________________________________________
1161 {
1162  //tag tracks as reference particles (RPs)
1163  for (Int_t i=0; i<fNumberOfTracks; i++)
1164  {
1165  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1166  if (!track) continue;
1167  Bool_t pass=cuts->PassesCuts(track);
1168  Bool_t rpTrack=track->InRPSelection();
1169  if (pass)
1170  {
1171  if (!rpTrack) fNumberOfPOIs[0]++; //only increase if not already tagged
1172  }
1173  else
1174  {
1175  if (rpTrack) fNumberOfPOIs[0]--; //only decrease if detagging
1176  }
1177  track->SetForRPSelection(pass);
1178  }
1179 }
1180 
1181 //_____________________________________________________________________________
1183 {
1184  //tag tracks as particles of interest (POIs)
1185  for (Int_t i=0; i<fNumberOfTracks; i++)
1186  {
1187  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1188  if (!track) continue;
1189  Bool_t pass=cuts->PassesCuts(track);
1190  Bool_t poiTrack=track->InPOISelection();
1191  if (pass)
1192  {
1193  if (!poiTrack) fNumberOfPOIs[poiType]++; //only increase if not already tagged
1194  }
1195  else
1196  {
1197  if (poiTrack) fNumberOfPOIs[poiType]--; //only decrease if detagging
1198  }
1199  track->Tag(poiType,pass);
1200  }
1201 }
1202 
1203 //_____________________________________________________________________________
1205 {
1206  // simple interface to tagging poi's and rp's
1207  TagPOI(cutsRP, 0);
1208  TagPOI(cutsPOI, 1);
1209 }
1210 //_____________________________________________________________________________
1212  Double_t etaMax,
1213  Double_t phiMin,
1214  Double_t phiMax )
1215 {
1216  //mark tracks in given eta-phi region as dead
1217  //by resetting the flow bits
1218  for (Int_t i=0; i<fNumberOfTracks; i++)
1219  {
1220  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1221  Double_t eta = track->Eta();
1222  Double_t phi = track->Phi();
1223  if (eta>etaMin && eta<etaMax && phi>phiMin && phi<phiMax)
1224  {
1225  if (track->InRPSelection()) {fNumberOfPOIs[0]--;}
1226  for (Int_t j=1; j<fNumberOfPOItypes; j++)
1227  {
1228  if (track->CheckTag(j)) {fNumberOfPOIs[j]--;}
1229  }
1230  track->ResetPOItype();
1231  }
1232  }
1233 }
1234 
1235 //_____________________________________________________________________________
1237 {
1238  //remove tracks that have no flow tags set and cleanup the container
1239  //returns number of cleaned tracks
1240  Int_t ncleaned=0;
1241  for (Int_t i=0; i<fNumberOfTracks; i++)
1242  {
1243  AliFlowTrackSimple* track = static_cast<AliFlowTrackSimple*>(fTrackCollection->At(i));
1244  if (!track) continue;
1245  if (track->IsDead()) {delete track;track=NULL;ncleaned++;}
1246  }
1247  fTrackCollection->Compress(); //clean up empty slots
1248  fNumberOfTracks-=ncleaned; //update number of tracks
1249  delete [] fShuffledIndexes; fShuffledIndexes=NULL;
1250  return ncleaned;
1251 }
1252 
1253 //_____________________________________________________________________________
1255 {
1256  //return a standard pt dependent v2 formula, user has to clean up!
1257  return new TF1("StandardPtDepV2","((x<1.0)*(0.05/1.0)*x+(x>=1.0)*0.05)");
1258 }
1259 
1260 //_____________________________________________________________________________
1262 {
1263  //returna standard pt and eta dependent v2 formula, user has to clean up!
1264  return new TF2 ("f","((x<1)*.1*x+(x>=1)*.1)*(1-0.2*TMath::Abs(y))");
1265 }
1266 
1267 //_____________________________________________________________________________
1269 {
1270  //return a standard pt spectrum, user has to clean up!
1271  return new TF1("StandardPtSpectrum","x*TMath::Exp(-pow(0.13957*0.13957+x*x,0.5)/0.4)",0.1,10.);
1272 }
1273 
1274 //_____________________________________________________________________________
1276 {
1277  //clear the counters without deleting allocated objects so they can be reused
1279  fNumberOfTracks = 0;
1280  for (Int_t i=0; i<fNumberOfPOItypes; i++)
1281  {
1282  fNumberOfPOIs[i] = 0;
1283  }
1284  fMCReactionPlaneAngle = 0.0;
1285  fMCReactionPlaneAngleIsSet = kFALSE;
1286  fAfterBurnerPrecision = 0.001;
1287  fUserModified = kFALSE;
1288  delete [] fShuffledIndexes; fShuffledIndexes=NULL;
1289 }
void SetCharge(Int_t charge)
Int_t charge
void Print(Option_t *option="") const
void SetForSubevent(Int_t i)
void Browse(TBrowser *b)
virtual void SetV02Qsub(Double_t QVCx, Double_t QVCy, Double_t MC, Double_t QVAx, Double_t QVAy, Double_t MA, Int_t har)
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)
void SetEta(Double_t eta)
virtual Int_t GetNDaughters() const
void AddV3(Double_t v3)
virtual void GetVertexPosition(Double_t *pos)
AliFlowTrackSimple * GetTrack(Int_t i)
void AddV1(Double_t v1, Double_t reactionPlaneAngle, Double_t precision, Int_t maxNumberOfIterations=100)
Bool_t InSubevent(Int_t i) const
Int_t GetNumberOfRPs() const
virtual void SetZDC2Qsub(Double_t *QVC, Double_t MC, Double_t *QVA, Double_t MA)
void AddV5(Double_t v5, Double_t reactionPlaneAngle, Double_t precision, Int_t maxNumberOfIterations=100)
void AddFlow(Double_t v1, Double_t v2, Double_t v3, Double_t v4, Double_t v5)
virtual AliFlowTrackSimple * Clone(const char *option="") const
TParameter< Int_t > * fNumberOfRPsWrap
number of tracks in TBrowser
void TagRP(const AliFlowTrackSimpleCuts *cuts)
static TF2 * SimplePtEtaDepV2()
void TagTracks(const AliFlowTrackSimpleCuts *cutsRP, const AliFlowTrackSimpleCuts *cutsPOI)
void AddV4(Double_t v4)
Double_t phiMin
AliFlowEventSimple & operator=(const AliFlowEventSimple &anEvent)
static TF1 * SimplePtSpectrum()
AliFlowVector fV0A[4]
void SetSubeventNumber(Int_t n)
Definition: AliFlowVector.h:51
void AddTrack(AliFlowTrackSimple *track)
void TagPOI(const AliFlowTrackSimpleCuts *cuts, Int_t poiType=1)
Bool_t PassesCuts(const AliFlowTrackSimple *track) const
void SetUserModified(Bool_t s=kTRUE)
TRandom * gRandom
void TagRP(Bool_t b=kTRUE)
Bool_t InRPSelection() const
virtual void SetVertexPosition(Double_t *pos)
void IncrementNumberOfPOIs(Int_t poiType=1)
Int_t * fShuffledIndexes
the angle of the reaction plane from the MC truth in TBrowser
TParameter< Double_t > * fMCReactionPlaneAngleWrap
number of tracks that have passed the POI selection in TBrowser
void SetForRPSelection(Bool_t b=kTRUE)
Double_t Phi() const
int Int_t
Definition: External.C:63
void SetHarmonic(Int_t h)
Definition: AliFlowVector.h:47
TParameter< Int_t > * fNumberOfPOIsWrap
number of tracks that have passed the RP selection in TBrowser
void SetNumberOfPOIs(Int_t nubmerOfPOIs, Int_t poiType=1)
void AddV4(Double_t v4, Double_t reactionPlaneAngle, Double_t precision, Int_t maxNumberOfIterations=100)
Int_t method
void ResolutionPt(Double_t res)
Double_t phiMax
void SetMult(Double_t mult)
Definition: AliFlowVector.h:45
Definition: External.C:212
Bool_t CheckTag(Int_t n)
Int_t GetNumberOfPOIs(Int_t i=1) const
void Tag(Int_t n, Bool_t b=kTRUE)
void AddV1(Double_t v1)
Bool_t IsDead() const
void ResolutionPt(Double_t resolution)
virtual void Generate(Int_t nParticles, TF1 *ptDist=NULL, Double_t phiMin=0.0, Double_t phiMax=TMath::TwoPi(), Double_t etaMin=-1.0, Double_t etaMax=1.0)
Bool_t fShuffleTracks
placeholder for randomized indexes
TObjArray * fTrackCollection
virtual void Get2Qsub(AliFlowVector *Qarray, Int_t n=2, TList *weightsList=NULL, Bool_t usePhiWeights=kFALSE, Bool_t usePtWeights=kFALSE, Bool_t useEtaWeights=kFALSE)
void SetPhi(Double_t phi)
void DefineDeadZone(Double_t etaMin, Double_t etaMax, Double_t phiMin, Double_t phiMax)
AliFlowTrackSimple * MakeNewTrack()
void SetPt(Double_t pt)
void AddV2(Double_t v2, Double_t reactionPlaneAngle, Double_t precision, Int_t maxNumberOfIterations=100)
void AddV5(Double_t v5)
void SetPOItype(Int_t t)
Definition: AliFlowVector.h:49
virtual void GetZDC2Qsub(AliFlowVector *Qarray)
void AddFlow(Double_t v1, Double_t v2, Double_t v3, Double_t v4, Double_t reactionPlaneAngle, Double_t precision, Int_t maxNumberOfIterations=100)
void AddV3(Double_t v3, Double_t reactionPlaneAngle, Double_t precision, Int_t maxNumberOfIterations=100)
Double_t Pt() const
TParameter< Int_t > * fNumberOfTracksWrap
virtual void GetV02Qsub(AliFlowVector *Qarray, Int_t har)
Double_t Weight() const
void AddV2(Double_t v2)
TObjArray * fMothersCollection
void TagSubeventsInEta(Double_t etaMinA, Double_t etaMaxA, Double_t etaMinB, Double_t etaMaxB)
void SetUseExternalSymmetryPlanes(TF1 *gPsi1Psi3=0x0, TF1 *gPsi2Psi4=0x0, TF1 *gPsi3Psi5=0x0)
static TF1 * SimplePtDepV2()
const char Option_t
Definition: External.C:48
Bool_t InPOISelection(Int_t poiType=1) const
Double_t Eta() const
AliFlowVector fV0C[4]
bool Bool_t
Definition: External.C:53
Double_t fCentrality
cache the particles with daughters
Bool_t MC(TH1F *hs, TH1F *hb, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmaused, Int_t &status)