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