76f904e51e14207d3073e7a9243ed287fb3fc15f
[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowSelection.cxx
1 //////////////////////////////////////////////////////////////////////
2 //
3 // $Id$
4 //
5 // Author: Emanuele Simili
6 //
7 //////////////////////////////////////////////////////////////////////
8 //_____________________________________________________________
9 //
10 // Description:  
11 //       the AliFlowSelection Class selects tracks from the AliFlowEvent. 
12 // There are two kind of selection :
13 // - Selection of tracks for the R.P. determination is performed via the
14 //  method Select(AliFlowTrack*): it simply checks the labels array of 
15 //  the track. Those arrays must be previously filled by calling 
16 //  AliFlowEvent::SetSelection(), wich uses the static cuts defined here.
17 //  Set the flag to Select via SetHarmonic() and SetSelection().   
18 // - Selection of tracks for Correlation Analysis is performed via the 
19 //  method SelectPart(AliFlowEvent*): cuts are applied to tracks 
20 //  (such as p.id, pT, total P, rapidity, eta, number of fit points, 
21 //  ratio of fit points to max points, chi2, and global dca). 
22 //  Set the cuts to apply via the appropriate Set...() methods.
23 // 
24 // The AliFlowSelection Class is adapted from the original StFlowSelection,
25 // succesfully used to study flow in the STAR experiment at RICH.
26 // Original Authors:                 Raimond Snellings & Art Poskanzer
27 //
28
29 #include "AliFlowSelection.h"
30 #include "AliFlowConstants.h"
31 #include <iostream>
32 using namespace std; //required for resolving the 'cout' symbol
33
34 // - 1st selection (both harmonic) is Disabled ! - the 2 following are the same (basic cuts, no P.id)
35 Float_t  AliFlowSelection::fEtaTpcCuts[2][Flow::nHars][Flow::nSels] = {{{1.0,0.0},{1.0,0.0}},{{0.0,1.1},{0.0,1.1}}} ;
36 Float_t  AliFlowSelection::fPtTpcCuts[2][Flow::nHars][Flow::nSels]  = {{{1.0,0.1},{1.0,0.1}},{{0.0,10.0},{0.0,10.0}}} ;
37 Float_t  AliFlowSelection::fDcaGlobalCuts[2]     = { 0. , 1. } ;
38 Char_t   AliFlowSelection::fPid[10]              = { '\0' } ;
39 Bool_t   AliFlowSelection::fConstrainable        = kTRUE ;
40 Int_t    AliFlowSelection::fTPChits[Flow::nSels] = { 0 , 1 } ;
41
42 ClassImp(AliFlowSelection)
43 //-----------------------------------------------------------------------
44 AliFlowSelection::AliFlowSelection()
45 {
46  // Default constructor: when initialized all selection cuts are disabled (lo>hi).
47
48  fCent                 = -1 ; 
49  fRun                  = -1 ; 
50  // -
51  fPidPart[0] = '\0' ;
52  fConstrainablePart    = kFALSE ;       // = kTRUE
53  fPidProbPart[0]       = 1 ;            // = 0.  
54  fPidProbPart[1]       = 0 ;            // = 1.  
55  fPtPart[0]            = 1 ;            // = 0.  
56  fPtPart[1]            = 0 ;            // = 10. 
57  fPPart[0]             = 1 ;            // = 0.  
58  fPPart[1]             = 0 ;            // = 10. 
59  fEtaPart[0]           = 1 ;            // = -0.9
60  fEtaPart[1]           = 0 ;            // = 0.9 
61  fEtaAbsPart[0]        = 1 ;            // = 0.
62  fEtaAbsPart[1]        = 0 ;            // = 0.9 
63  fFitPtsPart[0]        = 1 ;            // = 0   
64  fFitPtsPart[1]        = 0 ;            // = 0   
65  fDedxPtsPart[0]       = 1 ;            // = 0   
66  fDedxPtsPart[1]       = 0 ;            // = 0   
67  fFitOverMaxPtsPart[0] = 1 ;            // = 0.  
68  fFitOverMaxPtsPart[1] = 0 ;            // = 0.  
69  fChiSqPart[0]         = 1 ;            // = 0.  
70  fChiSqPart[1]         = 0 ;            // = 100.
71  fDcaGlobalPart[0]     = 1 ;            // = 0.  
72  fDcaGlobalPart[1]     = 0 ;            // = 1.  
73  fYPart[0]             = 1 ;            // = 0.  
74  fYPart[1]             = 0 ;            // = 0.  
75  // -
76  fV0Pid[10] = '\0' ;
77  fV0SideBand           = 0. ;
78  fV0Pt[0]              = 1 ;  
79  fV0Pt[1]              = 0 ;  
80  fV0P[0]               = 1 ;  
81  fV0P[1]               = 0 ;  
82  fV0Eta[0]             = 1 ;  
83  fV0Eta[1]             = 0 ;  
84  fV0EtaAbs[0]          = 1 ;  
85  fV0EtaAbs[1]          = 0 ;  
86  fV0Y[0]               = 1 ;  
87  fV0Y[1]               = 0 ;  
88  fV0ChiSq[0]           = 1 ;  
89  fV0ChiSq[1]           = 0 ;  
90  fV0Lenght[0]          = 1 ;  
91  fV0Lenght[1]          = 0 ;  
92  fV0LenghtOverSigma[0] = 1 ;  
93  fV0LenghtOverSigma[1] = 0 ;  
94  fV0DcaCross[0]        = 1 ;  
95  fV0DcaCross[1]        = 0 ;  
96  fV0Mass[0]            = 1 ;
97  fV0Mass[1]            = 0 ;
98  // -
99  fPtBinsPart           = Flow::nPtBinsPart ;  
100  // -                   
101  fHarmonic  = -1 ;   // harmonic
102  fSelection = -1 ;   // selection
103  fSubevent  = -1 ;   // sub-event
104 }
105 //-----------------------------------------------------------------------
106 AliFlowSelection::~AliFlowSelection() 
107 {
108  // default destructor (dummy)
109 }
110 //-----------------------------------------------------------------------
111 Bool_t AliFlowSelection::Select(AliFlowEvent* pFlowEvent) 
112 {
113  // Returns kTRUE if the event is selected. 
114
115  if((fCent>=0) && ((Int_t)pFlowEvent->Centrality() != fCent)) { return kFALSE ; }
116  //if(pFlowEvent->RunID() != fRun) { return kFALSE ; }
117  //if(pFlowEvent->... != ...) { return kFALSE ; }
118  
119  return kTRUE ;
120 }
121 //-----------------------------------------------------------------------
122 Bool_t AliFlowSelection::Select(AliFlowTrack* pFlowTrack)
123 {
124  // Selects particles for event plane determination.
125  // Returns kTRUE if the track is selected.
126  
127  if(!pFlowTrack->Select(fHarmonic, fSelection, fSubevent)) { return kFALSE ; }
128  return kTRUE ;
129 }
130 //-----------------------------------------------------------------------
131 Bool_t AliFlowSelection::Select(AliFlowV0* pFlowV0) 
132 {
133  // Returns kTRUE if the v0 is selected. (dummy) 
134
135  if(!pFlowV0) { return kFALSE ; }
136  return kTRUE ;
137 }
138 //-----------------------------------------------------------------------
139 Bool_t AliFlowSelection::SelectPart(AliFlowTrack* pFlowTrack) 
140 {
141  // Make track selection for Correlation Analysis & Vn (charged particles 
142  // to correlate with the event plane).  
143  // Returns kTRUE if the track is selected.
144
145  // PID
146  if(fPidPart[0] != '\0') 
147  {
148   if(strstr(fPidPart, "h")!=0)                                  // if fPidPart contains the char "h" 
149   {
150    int charge = pFlowTrack->Charge();
151    if(strcmp("h+", fPidPart)==0 && charge != 1)  return kFALSE; // if fPidPart == "h+"
152    if(strcmp("h-", fPidPart)==0 && charge != -1) return kFALSE;
153   } 
154   else 
155   {
156    const Char_t* pid = pFlowTrack->Pid() ;
157    if(strstr(pid, fPidPart)==0) return kFALSE;                  // if pFlowTrack->Pid() does not contain fPidPart (RP. selected parts.)
158   }
159  } 
160  
161  // PID probability
162  float pidProb = pFlowTrack->MostLikelihoodProb() ;
163  if (fPidProbPart[1] > fPidProbPart[0] &&  (pidProb < fPidProbPart[0] || pidProb > fPidProbPart[1])) return kFALSE;
164  
165  // Constrainable
166  bool constrainable = pFlowTrack->IsConstrainable() ;
167  if (fConstrainablePart && !constrainable)  return kFALSE;
168  
169  // Pt
170  float pt = pFlowTrack->Pt();
171  if (fPtPart[1] > fPtPart[0] &&  (pt < fPtPart[0] || pt > fPtPart[1])) return kFALSE;
172  
173  // P
174  float totalp = pFlowTrack->P();
175  if (fPPart[1] > fPPart[0] && (totalp < fPPart[0] || totalp > fPPart[1])) return kFALSE;
176  
177  // Eta
178  float eta = pFlowTrack->Eta();
179  if (fEtaPart[1] > fEtaPart[0] && (eta < fEtaPart[0] || eta > fEtaPart[1])) return kFALSE;
180  
181  // |Eta|
182  float absEta = TMath::Abs(pFlowTrack->Eta());
183  if (fEtaAbsPart[1] > fEtaAbsPart[0] && (absEta < fEtaAbsPart[0] || absEta > fEtaAbsPart[1])) return kFALSE;
184  
185  // Fit Points (TPC)
186  int fitPts = pFlowTrack->FitPtsTPC();
187  if (fFitPtsPart[1] > fFitPtsPart[0] && (fitPts < fFitPtsPart[0] || fitPts > fFitPtsPart[1])) return kFALSE;
188  
189  // Fit Points over Max Points (TPC)
190  int maxPts = pFlowTrack->MaxPtsTPC();
191  if(maxPts) 
192  { 
193   float fitOverMaxPts = (float)(fitPts)/(float)maxPts ;
194   if (fFitOverMaxPtsPart[1] > fFitOverMaxPtsPart[0] && (fitOverMaxPts < fFitOverMaxPtsPart[0] || fitOverMaxPts > fFitOverMaxPtsPart[1])) return kFALSE;
195  }
196  
197  // Chi Squared (main Vertex)
198  float chiSq = pFlowTrack->Chi2();
199  if (fChiSqPart[1] > fChiSqPart[0] && (chiSq < fChiSqPart[0] || chiSq > fChiSqPart[1])) return kFALSE;
200  
201  // DCA Global
202  float globdca = pFlowTrack->Dca();
203  if (fDcaGlobalPart[1] > fDcaGlobalPart[0] && (globdca < fDcaGlobalPart[0] || globdca > fDcaGlobalPart[1])) return kFALSE;
204
205  // Rapidity
206  float Y = pFlowTrack->Y();
207  if (fYPart[1] > fYPart[0] && (Y < fYPart[0] || Y > fYPart[1])) return kFALSE;
208
209  return kTRUE;
210 }
211 //-----------------------------------------------------------------------
212 Bool_t AliFlowSelection::SelectPart(AliFlowV0* pFlowV0) 
213 {
214  // Make v0 selection for Correlation Analysis & Vn (neutral particles 
215  // to correlate with the event plane).  
216  // Returns kTRUE if the v0 is selected.
217
218  // PID
219  if(fV0Pid[0] != '\0') 
220  {
221   if(strstr(fV0Pid, '\0')!=0)
222   {
223    int charge = pFlowV0->Charge();
224    if(strcmp("0", fV0Pid)==0 && charge != 0) return kFALSE;
225   } 
226   else 
227   {
228    const Char_t* pid = pFlowV0->Pid() ;
229    if(strstr(pid, fV0Pid)==0) return kFALSE;
230   }
231  }
232
233  // InvMass
234  float mass = pFlowV0->Mass() ;
235  if(fV0Mass[1]>fV0Mass[0])
236  {
237   float massMin = fV0Mass[0]-fV0SideBand ;
238   float massMax = fV0Mass[1]+fV0SideBand ;
239   if((mass < massMin) || (mass > massMax)) return kFALSE ;
240  }
241
242  // Pt
243  float pt = pFlowV0->Pt();
244  if (fV0Pt[1] > fV0Pt[0] &&  (pt < fV0Pt[0] || pt > fV0Pt[1])) return kFALSE;
245
246  // P
247  float totalp = pFlowV0->P();
248  if (fV0P[1] > fV0P[0] && (totalp < fV0P[0] || totalp > fV0P[1])) return kFALSE;
249
250  // Eta
251  float eta = pFlowV0->Eta();
252  if (fV0Eta[1] > fV0Eta[0] && (eta < fV0Eta[0] || eta > fV0Eta[1])) return kFALSE;
253  
254  // |Eta|
255  float absEta = TMath::Abs(pFlowV0->Eta());
256  if (fV0EtaAbs[1] > fV0EtaAbs[0] && (absEta < fV0EtaAbs[0] || absEta > fV0EtaAbs[1])) return kFALSE;
257  
258  // Chi Squared (main Vertex)
259  float chiSq = pFlowV0->Chi2();
260  if (fV0ChiSq[1] > fV0ChiSq[0] && (chiSq < fV0ChiSq[0] || chiSq > fV0ChiSq[1])) return kFALSE;
261
262  // DCA Cross
263  float cdca = pFlowV0->CrossDca() ;
264  if (fV0DcaCross[1] > fV0DcaCross[0] && (cdca < fV0DcaCross[0] || cdca > fV0DcaCross[1])) return kFALSE;
265
266  // V0 lenght
267  float lenght = pFlowV0->V0Lenght() ;
268  if (fV0Lenght[1] > fV0Lenght[0] && (lenght < fV0Lenght[0] || lenght > fV0Lenght[1])) return kFALSE;
269
270  // V0 lenght
271  float sigma  = pFlowV0->Sigma() ;
272  if(sigma) 
273  {
274   float lenghtOverSigma = lenght/sigma ;
275   if (fV0LenghtOverSigma[1] > fV0LenghtOverSigma[0] && (lenghtOverSigma < fV0LenghtOverSigma[0] || lenghtOverSigma > fV0LenghtOverSigma[1])) return kFALSE;
276  }
277
278  // Rapidity
279  float Y = pFlowV0->Y();
280  if (fV0Y[1] > fV0Y[0] && (Y < fV0Y[0] || Y > fV0Y[1])) return kFALSE;
281
282  return kTRUE;
283 }
284 //-----------------------------------------------------------------------
285 Bool_t  AliFlowSelection::SelectV0Part(AliFlowV0* pFlowV0)
286
287  // selects v0s in the invariant Mass window
288  
289  float mass = pFlowV0->Mass() ;
290  if(fV0Mass[1]>fV0Mass[0])
291  {
292   if(mass < fV0Mass[0] || mass > fV0Mass[1]) return kFALSE ; 
293  } 
294  return kTRUE;
295 }
296 //-----------------------------------------------------------------------
297 Bool_t  AliFlowSelection::SelectV0Side(AliFlowV0* pFlowV0)
298
299  // selects v0s in the sidebands of the Mass window
300  float mass = pFlowV0->Mass() ;
301  if(fV0Mass[1]>fV0Mass[0])
302  { 
303   float massMin = fV0Mass[0]-fV0SideBand ;
304   float massMax = fV0Mass[1]+fV0SideBand ;
305   if((mass < massMin) || (mass >= fV0Mass[0] && mass <= fV0Mass[1]) || (mass > massMax)) return kFALSE ;
306  }
307  return kTRUE;
308 }
309 //-----------------------------------------------------------------------
310 Bool_t  AliFlowSelection::SelectV0sxSide(AliFlowV0* pFlowV0)
311
312  // selects v0s in the left hand sideband
313  float mass = pFlowV0->Mass() ;
314  float massMin = fV0Mass[0]-fV0SideBand ;
315  if((mass >= massMin) && (mass < fV0Mass[0]))   { return kTRUE ; }
316  else                                           { return kFALSE ; }
317 }
318 //-----------------------------------------------------------------------
319 Bool_t  AliFlowSelection::SelectV0dxSide(AliFlowV0* pFlowV0)
320
321  // selects v0s in the right hand sideband
322  float mass = pFlowV0->Mass() ;
323  float massMax = fV0Mass[1]+fV0SideBand ;
324  if((mass > fV0Mass[1]) && (mass <= massMax))   { return kTRUE ; }
325  else                                           { return kFALSE ; }
326 }
327 //-----------------------------------------------------------------------
328 void AliFlowSelection::PrintList() const 
329 {
330  // Prints the selection criteria for correlation analysis
331
332  cout << "#################################################################" << endl;
333  cout << "# Selection List (particles correlated to the event plane):" << endl;
334  cout << "# " << endl;
335  if(fPidPart[0]!='\0') 
336  { cout << "# P.id for particles correlated to the event plane: " << fPidPart << "  " <<endl ; }
337  if(fPtPart[1]>fPtPart[0]) 
338  { cout << "# Pt for particles correlated to the event plane: " << fPtPart[0] << " to " << fPtPart[1] << " GeV/c" <<endl ; }
339  if(fPPart[1]>fPPart[0]) 
340  { cout << "# P for particles correlated to the event plane: " << fPPart[0] << " to " << fPPart[1] << " GeV/c" <<endl ; }
341  if(fEtaPart[1]>fEtaPart[0]) 
342  { cout << "# Eta for particles correlated to the event plane: " << fEtaPart[0] << " to " << fEtaPart[1] <<endl ; }
343  if(fEtaAbsPart[1]>fEtaAbsPart[0]) 
344  { cout << "# |Eta| for V0s correlated to the event plane: " << fEtaAbsPart[0] << " to " << fEtaAbsPart[1] <<endl ; }
345  if(fYPart[1]>fYPart[0]) 
346  { cout << "# Y for particles correlated to the event plane: " << fYPart[0] << " to " << fYPart[1] <<endl ; }
347  if(fFitPtsPart[1]>fFitPtsPart[0]) 
348  { cout << "# Fit Points for particles correlated to the event plane: " << fFitPtsPart[0] << " to " << fFitPtsPart[1] <<endl ; }
349  if(fDedxPtsPart[1]>fDedxPtsPart[0]) 
350  { cout << "# Dedx Points for particles correlated to the event plane: " << fDedxPtsPart[0] << " to " << fDedxPtsPart[1] << endl ; }
351  if(fFitOverMaxPtsPart[1]>fFitOverMaxPtsPart[0]) 
352  { cout << "# Fit/Max Points for particles correlated to the event plane: " << fFitOverMaxPtsPart[0] << " to " << fFitOverMaxPtsPart[1] <<endl ; }
353  if(fChiSqPart[1]>fChiSqPart[0]) 
354  { cout << "# Chi2 for particles correlated to the event plane: " << fChiSqPart[0] << " to " << fChiSqPart[1] <<endl ; }
355  if(fDcaGlobalPart[1]>fDcaGlobalPart[0]) 
356  { cout << "# Global Dca for particles correlated with the event plane: " << fDcaGlobalPart[0] << " to " << fDcaGlobalPart[1] <<endl ; }
357  if(fConstrainablePart)          { cout << "# Constrainability cut:   Constrained  Tracks " << endl ; }
358  cout << "#################################################################" << endl;
359 }
360 //-----------------------------------------------------------------------
361 void AliFlowSelection::PrintV0List() const 
362 {
363  // Prints the selection criteria for V0s
364
365  cout << "#################################################################" << endl;
366  cout << "# Selection List (V0s correlated with the event plane):" << endl;
367  cout << "# " << endl;
368  if(fV0Pid[0]!='\0') 
369  { cout << "# P.id for V0s correlated to the event plane: " << fV0Pid << "  " <<endl ; }
370  if(fV0Mass[1]>fV0Mass[0]) 
371  {
372   if(!fV0SideBand)
373   { cout << "# Invariant Mass for V0s correlated to the event plane: " << fV0Mass[0] << " to " << fV0Mass[1] << endl ; }
374   else
375   { cout << "# Invariant Mass for V0-SideBands correlated to the event plane: " << fV0Mass[0]-fV0SideBand << " to " << fV0Mass[0]  << " & " << fV0Mass[1] << " to " << fV0Mass[1]+fV0SideBand << endl ; }
376  }
377  if(fV0Pt[1]>fV0Pt[0]) 
378  { cout << "# Pt for V0s correlated to the event plane: " << fV0Pt[0] << " to " << fV0Pt[1] << " GeV/c" <<endl ; }
379  if(fV0P[1]>fV0P[0]) 
380  { cout << "# P for V0s correlated to the event plane: " << fV0P[0] << " to " << fV0P[1] << " GeV/c" <<endl ; }
381  if(fV0Eta[1]>fV0Eta[0]) 
382  { cout << "# Eta for V0s correlated to the event plane: " << fV0Eta[0] << " to " << fV0Eta[1] <<endl ; }
383  if(fV0EtaAbs[1]>fV0EtaAbs[0]) 
384  { cout << "# |Eta| for V0s correlated to the event plane: " << fV0EtaAbs[0] << " to " << fV0EtaAbs[1] <<endl ; }
385  if(fV0Y[1]>fV0Y[0]) 
386  { cout << "# Y for V0s correlated to the event plane: " << fV0Y[0] << " to " << fV0Y[1] <<endl ; }
387  if(fV0ChiSq[1]>fV0ChiSq[0]) 
388  { cout << "# Chi2 for V0s correlated to the event plane: " << fV0ChiSq[0] << " to " << fV0ChiSq[1] <<endl ; }
389  if(fV0DcaCross[1]>fV0DcaCross[0]) 
390  { cout << "# Closest approach between the daughter tracks for V0s correlated to the event plane: " << fV0DcaCross[0] << " to " << fV0DcaCross[1] <<endl ; }
391  if(fV0Lenght[1]>fV0Lenght[0]) 
392  { cout << "# ... for V0s correlated to the event plane: " << fV0Lenght[0] << " to " << fV0Lenght[1] <<endl ; }
393  if(fV0LenghtOverSigma[1]>fV0LenghtOverSigma[0]) 
394  { cout << "# ... for V0s correlated to the event plane: " << fV0LenghtOverSigma[0] << " to " << fV0LenghtOverSigma[1] <<endl ; }
395  cout << "#################################################################" << endl;
396 }
397 //-----------------------------------------------------------------------
398 void AliFlowSelection::PrintSelectionList() const
399 {
400  // Prints the list of selection cuts for RP determination
401  
402  if(fCent>=0)      
403  { 
404   cout << "#######################################################" << endl;
405   cout << "# Event centrality: " << endl ; 
406   float lowC, hiC ;
407   if(fCent==0)      { lowC=0 ; hiC=Flow::fCentNorm[0] * Flow::fMaxMult ; }
408   else if(fCent>8)  { lowC=Flow::fCentNorm[8] * Flow::fMaxMult ; hiC=99999 ; }
409   else              { lowC=Flow::fCentNorm[fCent-1] * Flow::fMaxMult ; hiC=Flow::fCentNorm[fCent] * Flow::fMaxMult ; }
410   cout << "#  - Centrality Class = " << fCent << " ( " << (int)lowC << " < mult < " << (int)hiC << " ) . " << endl ; 
411  }
412  else      
413  { 
414   cout << "#######################################################" << endl;
415   cout << "# All centralities " << endl ; 
416  }
417
418  cout << "#######################################################" << endl;
419  cout << "# Tracks used for the event plane: " << endl ; 
420  cout << "#  - Selection[0]    (for all " << Flow::nHars << " Harmonics) :  " << endl ; 
421  cout << "#   NO CUTS " << endl ; 
422  cout << "#  - Selection[1+]   (for all " << Flow::nHars << " Harmonics) : " << endl ; 
423  if(Pid()[0] != '\0')                   { cout << "#   Particle ID =  " << Pid() << endl ; } 
424  if(ConstrainCut())                     { cout << "#   Constrainable Tracks " << endl ; }
425  if(DcaGlobalCutHi()>DcaGlobalCutLo())  { cout << "#   Global Dca Tpc cuts =  " << DcaGlobalCutLo() << " , " << DcaGlobalCutHi() << endl ; }
426  for (int k = 1; k < Flow::nSels; k++) 
427  {
428   for (int j = 0; j < Flow::nHars ; j++) 
429   {
430    cout << "#  - Selection[" << k << "] , Harmonic[" << j+1 << "] :" << endl ;
431    if(NhitsCut(k))                      { cout << "#   Minimum TPC hits =  " << NhitsCut(k) << endl ; }
432    if(EtaCutHi(j,k)>EtaCutLo(j,k))      { cout << "#   TMath::Abs(Eta) cuts =  " << EtaCutLo(j,k) << " , "  << EtaCutHi(j,k) << endl ; }
433    if(PtCutHi(j,k)>PtCutLo(j,k))        { cout << "#   Pt cuts = " << PtCutLo(j,k) << " , "  << PtCutHi(j,k) << endl ; }
434   }
435  }
436  cout << "#######################################################" << endl;  
437 }
438 //-----------------------------------------------------------------------
439 void AliFlowSelection::SetHarmonic(const Int_t& harN) 
440 {
441  if (harN < 0 || harN >= Flow::nHars) 
442  {
443   cout << "### Harmonic " << harN << " not valid" << endl;
444   fHarmonic = 0;
445  } 
446  else { fHarmonic = harN; } 
447 }
448 //-----------------------------------------------------------------------
449 void AliFlowSelection::SetSelection(const Int_t& selN) 
450 {
451  if (selN < 0 || selN >= Flow::nSels) 
452  {
453   cout << "### Selection " << selN << " not valid" << endl;
454   fSelection = 0;
455  } 
456  else { fSelection = selN; } 
457 }
458 //-----------------------------------------------------------------------
459 void AliFlowSelection::SetSubevent(const Int_t& subN) 
460 {
461  if (subN < -1 || subN > Flow::nSubs) 
462  {
463   cout << "### Subevent " << subN << " not valid" << endl;
464   fSubevent = -1;
465  } 
466  else { fSubevent = subN; } 
467 }
468 //-----------------------------------------------------------------------
469 void AliFlowSelection::SetEtaCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN) 
470
471  fEtaTpcCuts[0][harN][selN] = lo ; 
472  fEtaTpcCuts[1][harN][selN] = hi ; 
473 }
474 //-----------------------------------------------------------------------
475 void AliFlowSelection::SetPtCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN)  
476
477  fPtTpcCuts[0][harN][selN] = lo  ; 
478  fPtTpcCuts[1][harN][selN] = hi ; 
479 }
480 //-----------------------------------------------------------------------
481 void AliFlowSelection::SetDcaGlobalCut(Float_t lo, Float_t hi)      
482
483  fDcaGlobalCuts[0] = lo ; 
484  fDcaGlobalCuts[1] = hi ; 
485 }
486 //-----------------------------------------------------------------------
487 void AliFlowSelection::SetPidCut(const Char_t* pid)            
488
489  strncpy(fPid, pid, 9) ; 
490  fPid[9] = '\0' ; 
491 }
492 //-----------------------------------------------------------------------
493 void AliFlowSelection::SetConstrainCut(Bool_t tf) 
494
495  fConstrainable = tf ; 
496 }
497 //-----------------------------------------------------------------------
498 void AliFlowSelection::SetNhitsCut(Int_t hits,Int_t selN)
499
500  fTPChits[selN] = hits; 
501 }
502 //-----------------------------------------------------------------------
503 Float_t AliFlowSelection::PtMaxPart() const                            
504
505  if(fPtPart[1]>fPtPart[0]) { return fPtPart[1] ; } 
506  else { return 0. ; } 
507 }
508 //-----------------------------------------------------------------------