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