]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG/FLOW/Tasks/AliFlowTrackCuts.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
calibrate the vzero signal that goes into the total Q-vector which can be retrieved...
[u/mrichter/AliRoot.git] / PWG / FLOW / Tasks / AliFlowTrackCuts.cxx
CommitLineData
daf66719 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. *
86a97121 14 **********************************************************i****************/
daf66719 15
16/* $Id$ */
17
18// AliFlowTrackCuts:
3c67c769 19// Data selection for flow framework
daf66719 20//
21// origin: Mikolaj Krzewicki (mikolaj.krzewicki@cern.ch)
86a97121 22// mods: Redmer A. Bertens (rbertens@cern.ch)
5559ce24 23//
24// This class gurantees consistency of cut methods, trackparameter
25// selection (global tracks, TPC only, etc..) and parameter mixing
26// in the flow framework. Transparently handles different input types:
27// ESD, MC, AOD.
28// This class works in 2 steps: first the requested track parameters are
29// constructed (to be set by SetParamType() ), then cuts are applied.
30// the constructed track can be requested AFTER checking the cuts by
31// calling GetTrack(), in this case the cut object stays in control,
32// caller does not have to delete the track.
33// Additionally caller can request an AliFlowTrack object to be constructed
34// according the parameter mixing scenario requested by SetParamMix().
35// AliFlowTrack is made using MakeFlowTrack() method, its an 'object factory'
36// so caller needs to take care of the freshly created object.
daf66719 37
38#include <limits.h>
39#include <float.h>
32b846cd 40#include <TMatrix.h>
875ee12a 41#include "TMCProcess.h"
9a0783cc 42#include "TParticle.h"
1a80f9f6 43#include "TH2F.h"
9a0783cc 44#include "AliStack.h"
499fe731 45#include "TBrowser.h"
84b44ed4 46#include "TArrayD.h"
daf66719 47#include "AliMCEvent.h"
9a0783cc 48#include "AliESDEvent.h"
8eca5d19 49#include "AliAODEvent.h"
daf66719 50#include "AliVParticle.h"
86a97121 51#include "AliVVZERO.h"
daf66719 52#include "AliMCParticle.h"
dd294bb6
MK		 53#include "AliESDkink.h"
54#include "AliESDv0.h"
daf66719 55#include "AliESDtrack.h"
2e5052c5 56#include "AliESDMuonTrack.h" // XZhang 20120604
12b2b8bc 57#include "AliMultiplicity.h"
daf66719 58#include "AliAODTrack.h"
2e5052c5 59#include "AliAODTracklets.h" // XZhang 20120615
8eca5d19 60#include "AliFlowTrackSimple.h"
daf66719 61#include "AliFlowTrack.h"
62#include "AliFlowTrackCuts.h"
63#include "AliLog.h"
32b846cd 64#include "AliESDpid.h"
d148af7e 65#include "AliESDPmdTrack.h"
92b507bb 66#include "AliESDUtils.h" //TODO
cc0afcfc 67#include "AliFlowBayesianPID.h"
dd294bb6
MK		 68#include "AliFlowCandidateTrack.h"
69#include "AliKFParticle.h"
70#include "AliESDVZERO.h"
71#include "AliFlowCommonConstants.h"
043e9010 72#include "AliAnalysisManager.h"
73#include "AliPIDResponse.h"
daf66719 74
75ClassImp(AliFlowTrackCuts)
76
77//-----------------------------------------------------------------------
78AliFlowTrackCuts::AliFlowTrackCuts():
441ea1cf 79 AliFlowTrackSimpleCuts(),
80 fAliESDtrackCuts(NULL),
2e5052c5 81 fMuonTrackCuts(NULL), // XZhang 20120604
441ea1cf 82 fQA(NULL),
83 fCutMC(kFALSE),
f21bdf48 84 fCutMChasTrackReferences(kFALSE),
441ea1cf 85 fCutMCprocessType(kFALSE),
86 fMCprocessType(kPNoProcess),
87 fCutMCPID(kFALSE),
88 fMCPID(0),
2ed97fda 89 fCutMCfirstMotherPID(kFALSE),
90 fMCfirstMotherPID(0),
a14b8f3c 91 fIgnoreSignInMCPID(kFALSE),
441ea1cf 92 fCutMCisPrimary(kFALSE),
93 fRequireTransportBitForPrimaries(kTRUE),
94 fMCisPrimary(kFALSE),
95 fRequireCharge(kFALSE),
96 fFakesAreOK(kTRUE),
97 fCutSPDtrackletDeltaPhi(kFALSE),
98 fSPDtrackletDeltaPhiMax(FLT_MAX),
99 fSPDtrackletDeltaPhiMin(-FLT_MAX),
100 fIgnoreTPCzRange(kFALSE),
101 fIgnoreTPCzRangeMax(FLT_MAX),
102 fIgnoreTPCzRangeMin(-FLT_MAX),
103 fCutChi2PerClusterTPC(kFALSE),
104 fMaxChi2PerClusterTPC(FLT_MAX),
105 fMinChi2PerClusterTPC(-FLT_MAX),
106 fCutNClustersTPC(kFALSE),
107 fNClustersTPCMax(INT_MAX),
108 fNClustersTPCMin(INT_MIN),
42655d16 109 fCutNClustersITS(kFALSE),
110 fNClustersITSMax(INT_MAX),
111 fNClustersITSMin(INT_MIN),
549b5f40
RAB		 112 fUseAODFilterBit(kTRUE),
113 fAODFilterBit(1),
a63303bd 114 fCutDCAToVertexXY(kFALSE),
115 fCutDCAToVertexZ(kFALSE),
2b1eaa10 116 fCutMinimalTPCdedx(kFALSE),
117 fMinimalTPCdedx(0.),
92b507bb 118 fLinearizeVZEROresponse(kFALSE),
1a80f9f6 119 fCutPmdDet(kFALSE),
120 fPmdDet(0),
121 fCutPmdAdc(kFALSE),
122 fPmdAdc(0.),
123 fCutPmdNcell(kFALSE),
124 fPmdNcell(0.),
dd294bb6
MK		 125 fMinKinkAngle(TMath::DegToRad()*2.),
126 fMinKinkRadius(130.),
127 fMaxKinkRadius(200.),
128 fMinKinkQt(.05),
129 fMaxKinkQt(.5),
130 fMinKinkInvMassKmu(0.),
131 fMaxKinkInvMassKmu(0.6),
132 fForceTPCstandalone(kFALSE),
133 fRequireKinkDaughters(kFALSE),
441ea1cf 134 fParamType(kGlobal),
135 fParamMix(kPure),
dd294bb6
MK		 136 fKink(NULL),
137 fV0(NULL),
441ea1cf 138 fTrack(NULL),
dd294bb6
MK		 139 fTrackMass(0.),
140 fTrackPt(0.),
441ea1cf 141 fTrackPhi(0.),
142 fTrackEta(0.),
2281e7c5 143 fTrackWeight(1.),
441ea1cf 144 fTrackLabel(INT_MIN),
145 fMCevent(NULL),
146 fMCparticle(NULL),
147 fEvent(NULL),
148 fTPCtrack(),
aab6527a 149 fESDpid(),
9126fd0c 150 fBayesianResponse(NULL),
2b1eaa10 151 fPIDsource(kTOFpid),
441ea1cf 152 fTPCpidCuts(NULL),
153 fTOFpidCuts(NULL),
a14b8f3c 154 fParticleID(AliPID::kUnknown),
499fe731 155 fParticleProbability(.9),
875ee12a 156 fAllowTOFmismatchFlag(kFALSE),
0b14d0f4 157 fRequireStrictTOFTPCagreement(kFALSE),
9126fd0c 158 fCutRejectElectronsWithTPCpid(kFALSE),
8b649d8c 159 fProbBayes(0.0),
86a97121 160 fCurrCentr(0.0),
c27333c2 161 fVZEROgainEqualization(NULL),
86a97121 162 fApplyRecentering(kFALSE),
043e9010 163 fVZEROgainEqualizationPerRing(kFALSE),
84b44ed4 164 fChi2A(0x0),
165 fChi2C(0x0),
166 fChi3A(0x0),
167 fChi3C(0x0),
043e9010 168 fPIDResponse(NULL),
169 fNsigmaCut2(9)
441ea1cf 170{
171 //io constructor
422c61c7 172 SetPriors(); //init arrays
b147dd2f 173
174 // New PID procedure (Bayesian Combined PID)
175 // allocating here is necessary because we don't
176 // stream this member
177 // TODO: fix streaming problems AliFlowBayesianPID
178 fBayesianResponse = new AliFlowBayesianPID();
179 fBayesianResponse->SetNewTrackParam();
86a97121 180 for(Int_t i(0); i < 4; i++) {
c27333c2
MK		 181 fVZEROApol[i] = 0;
182 fVZEROCpol[i] = 0;
86a97121 183 }
184 for(Int_t i(0); i < 8; i++) fUseVZERORing[i] = kTRUE;
b147dd2f 185
441ea1cf 186}
187
188//-----------------------------------------------------------------------
189AliFlowTrackCuts::AliFlowTrackCuts(const char* name):
cc0afcfc 190 AliFlowTrackSimpleCuts(name),
1a80f9f6 191 fAliESDtrackCuts(NULL),
2e5052c5 192 fMuonTrackCuts(NULL), // XZhang 20120604
a1c43d26 193 fQA(NULL),
1ff4bda1 194 fCutMC(kFALSE),
f21bdf48 195 fCutMChasTrackReferences(kFALSE),
daf66719 196 fCutMCprocessType(kFALSE),
197 fMCprocessType(kPNoProcess),
198 fCutMCPID(kFALSE),
199 fMCPID(0),
2ed97fda 200 fCutMCfirstMotherPID(kFALSE),
201 fMCfirstMotherPID(0),
a14b8f3c 202 fIgnoreSignInMCPID(kFALSE),
daf66719 203 fCutMCisPrimary(kFALSE),
441ea1cf 204 fRequireTransportBitForPrimaries(kTRUE),
daf66719 205 fMCisPrimary(kFALSE),
957517fa 206 fRequireCharge(kFALSE),
127a5825 207 fFakesAreOK(kTRUE),
9a0783cc 208 fCutSPDtrackletDeltaPhi(kFALSE),
209 fSPDtrackletDeltaPhiMax(FLT_MAX),
210 fSPDtrackletDeltaPhiMin(-FLT_MAX),
1ff4bda1 211 fIgnoreTPCzRange(kFALSE),
212 fIgnoreTPCzRangeMax(FLT_MAX),
213 fIgnoreTPCzRangeMin(-FLT_MAX),
2948ac5a 214 fCutChi2PerClusterTPC(kFALSE),
215 fMaxChi2PerClusterTPC(FLT_MAX),
216 fMinChi2PerClusterTPC(-FLT_MAX),
32b846cd 217 fCutNClustersTPC(kFALSE),
218 fNClustersTPCMax(INT_MAX),
219 fNClustersTPCMin(INT_MIN),
42655d16 220 fCutNClustersITS(kFALSE),
221 fNClustersITSMax(INT_MAX),
5ba02b32 222 fNClustersITSMin(INT_MIN),
549b5f40
RAB		 223 fUseAODFilterBit(kTRUE),
224 fAODFilterBit(1),
a63303bd 225 fCutDCAToVertexXY(kFALSE),
226 fCutDCAToVertexZ(kFALSE),
2b1eaa10 227 fCutMinimalTPCdedx(kFALSE),
228 fMinimalTPCdedx(0.),
92b507bb 229 fLinearizeVZEROresponse(kFALSE),
1a80f9f6 230 fCutPmdDet(kFALSE),
231 fPmdDet(0),
232 fCutPmdAdc(kFALSE),
233 fPmdAdc(0.),
234 fCutPmdNcell(kFALSE),
235 fPmdNcell(0.),
dd294bb6
MK		 236 fMinKinkAngle(TMath::DegToRad()*2.),
237 fMinKinkRadius(130.),
238 fMaxKinkRadius(200.),
239 fMinKinkQt(0.05),
240 fMaxKinkQt(0.5),
241 fMinKinkInvMassKmu(0.0),
242 fMaxKinkInvMassKmu(0.6),
243 fForceTPCstandalone(kFALSE),
244 fRequireKinkDaughters(kFALSE),
12b2b8bc 245 fParamType(kGlobal),
daf66719 246 fParamMix(kPure),
dd294bb6
MK		 247 fKink(NULL),
248 fV0(NULL),
daf66719 249 fTrack(NULL),
dd294bb6
MK		 250 fTrackMass(0.),
251 fTrackPt(0.),
12b2b8bc 252 fTrackPhi(0.),
253 fTrackEta(0.),
2281e7c5 254 fTrackWeight(1.),
127a5825 255 fTrackLabel(INT_MIN),
957517fa 256 fMCevent(NULL),
9a0783cc 257 fMCparticle(NULL),
1ff4bda1 258 fEvent(NULL),
32b846cd 259 fTPCtrack(),
aab6527a 260 fESDpid(),
9126fd0c 261 fBayesianResponse(NULL),
2b1eaa10 262 fPIDsource(kTOFpid),
32b846cd 263 fTPCpidCuts(NULL),
264 fTOFpidCuts(NULL),
a14b8f3c 265 fParticleID(AliPID::kUnknown),
499fe731 266 fParticleProbability(.9),
875ee12a 267 fAllowTOFmismatchFlag(kFALSE),
0b14d0f4 268 fRequireStrictTOFTPCagreement(kFALSE),
9126fd0c 269 fCutRejectElectronsWithTPCpid(kFALSE),
8b649d8c 270 fProbBayes(0.0),
86a97121 271 fCurrCentr(0.0),
c27333c2 272 fVZEROgainEqualization(NULL),
86a97121 273 fApplyRecentering(kFALSE),
043e9010 274 fVZEROgainEqualizationPerRing(kFALSE),
84b44ed4 275 fChi2A(0x0),
276 fChi2C(0x0),
277 fChi3A(0x0),
278 fChi3C(0x0),
043e9010 279 fPIDResponse(NULL),
280 fNsigmaCut2(9)
daf66719 281{
282 //constructor
441ea1cf 283 SetTitle("AliFlowTrackCuts");
aab6527a 284 fESDpid.GetTPCResponse().SetBetheBlochParameters( 0.0283086,
285 2.63394e+01,
286 5.04114e-11,
287 2.12543e+00,
288 4.88663e+00 );
422c61c7 289 SetPriors(); //init arrays
1a80f9f6 290
9126fd0c 291 // New PID procedure (Bayesian Combined PID)
62f2ea04 292 fBayesianResponse = new AliFlowBayesianPID();
293 fBayesianResponse->SetNewTrackParam();
86a97121 294 for(Int_t i(0); i < 4; i++) {
c27333c2
MK		 295 fVZEROApol[i] = 0;
296 fVZEROCpol[i] = 0;
86a97121 297 }
298 for(Int_t i(0); i < 8; i++) fUseVZERORing[i] = kTRUE;
daf66719 299}
300
301//-----------------------------------------------------------------------
ee242db3 302AliFlowTrackCuts::AliFlowTrackCuts(const AliFlowTrackCuts& that):
303 AliFlowTrackSimpleCuts(that),
441ea1cf 304 fAliESDtrackCuts(NULL),
2e5052c5 305 fMuonTrackCuts(NULL), // XZhang 20120604
a1c43d26 306 fQA(NULL),
1ff4bda1 307 fCutMC(that.fCutMC),
f21bdf48 308 fCutMChasTrackReferences(that.fCutMChasTrackReferences),
ee242db3 309 fCutMCprocessType(that.fCutMCprocessType),
310 fMCprocessType(that.fMCprocessType),
311 fCutMCPID(that.fCutMCPID),
312 fMCPID(that.fMCPID),
2ed97fda 313 fCutMCfirstMotherPID(that.fCutMCfirstMotherPID),
314 fMCfirstMotherPID(that.fMCfirstMotherPID),
a14b8f3c 315 fIgnoreSignInMCPID(that.fIgnoreSignInMCPID),
ee242db3 316 fCutMCisPrimary(that.fCutMCisPrimary),
441ea1cf 317 fRequireTransportBitForPrimaries(that.fRequireTransportBitForPrimaries),
ee242db3 318 fMCisPrimary(that.fMCisPrimary),
319 fRequireCharge(that.fRequireCharge),
320 fFakesAreOK(that.fFakesAreOK),
321 fCutSPDtrackletDeltaPhi(that.fCutSPDtrackletDeltaPhi),
322 fSPDtrackletDeltaPhiMax(that.fSPDtrackletDeltaPhiMax),
323 fSPDtrackletDeltaPhiMin(that.fSPDtrackletDeltaPhiMin),
1ff4bda1 324 fIgnoreTPCzRange(that.fIgnoreTPCzRange),
325 fIgnoreTPCzRangeMax(that.fIgnoreTPCzRangeMax),
326 fIgnoreTPCzRangeMin(that.fIgnoreTPCzRangeMin),
2948ac5a 327 fCutChi2PerClusterTPC(that.fCutChi2PerClusterTPC),
328 fMaxChi2PerClusterTPC(that.fMaxChi2PerClusterTPC),
329 fMinChi2PerClusterTPC(that.fMinChi2PerClusterTPC),
32b846cd 330 fCutNClustersTPC(that.fCutNClustersTPC),
331 fNClustersTPCMax(that.fNClustersTPCMax),
332 fNClustersTPCMin(that.fNClustersTPCMin),
42655d16 333 fCutNClustersITS(that.fCutNClustersITS),
334 fNClustersITSMax(that.fNClustersITSMax),
335 fNClustersITSMin(that.fNClustersITSMin),
5ba02b32 336 fUseAODFilterBit(that.fUseAODFilterBit),
337 fAODFilterBit(that.fAODFilterBit),
a63303bd 338 fCutDCAToVertexXY(that.fCutDCAToVertexXY),
339 fCutDCAToVertexZ(that.fCutDCAToVertexZ),
2b1eaa10 340 fCutMinimalTPCdedx(that.fCutMinimalTPCdedx),
341 fMinimalTPCdedx(that.fMinimalTPCdedx),
92b507bb 342 fLinearizeVZEROresponse(that.fLinearizeVZEROresponse),
1a80f9f6 343 fCutPmdDet(that.fCutPmdDet),
344 fPmdDet(that.fPmdDet),
345 fCutPmdAdc(that.fCutPmdAdc),
346 fPmdAdc(that.fPmdAdc),
347 fCutPmdNcell(that.fCutPmdNcell),
348 fPmdNcell(that.fPmdNcell),
dd294bb6
MK		 349 fMinKinkAngle(that.fMinKinkAngle),
350 fMinKinkRadius(that.fMinKinkRadius),
351 fMaxKinkRadius(that.fMaxKinkRadius),
352 fMinKinkQt(that.fMinKinkQt),
353 fMaxKinkQt(that.fMaxKinkQt),
354 fMinKinkInvMassKmu(that.fMinKinkInvMassKmu),
355 fMaxKinkInvMassKmu(that.fMaxKinkInvMassKmu),
356 fForceTPCstandalone(that.fForceTPCstandalone),
357 fRequireKinkDaughters(that.fRequireKinkDaughters),
ee242db3 358 fParamType(that.fParamType),
359 fParamMix(that.fParamMix),
dd294bb6
MK		 360 fKink(NULL),
361 fV0(NULL),
daf66719 362 fTrack(NULL),
dd294bb6
MK		 363 fTrackMass(0.),
364 fTrackPt(0.),
ee242db3 365 fTrackPhi(0.),
366 fTrackEta(0.),
2281e7c5 367 fTrackWeight(1.),
127a5825 368 fTrackLabel(INT_MIN),
957517fa 369 fMCevent(NULL),
9a0783cc 370 fMCparticle(NULL),
1ff4bda1 371 fEvent(NULL),
32b846cd 372 fTPCtrack(),
373 fESDpid(that.fESDpid),
9126fd0c 374 fBayesianResponse(NULL),
32b846cd 375 fPIDsource(that.fPIDsource),
376 fTPCpidCuts(NULL),
377 fTOFpidCuts(NULL),
2b1eaa10 378 fParticleID(that.fParticleID),
499fe731 379 fParticleProbability(that.fParticleProbability),
875ee12a 380 fAllowTOFmismatchFlag(that.fAllowTOFmismatchFlag),
0b14d0f4 381 fRequireStrictTOFTPCagreement(that.fRequireStrictTOFTPCagreement),
9126fd0c 382 fCutRejectElectronsWithTPCpid(that.fCutRejectElectronsWithTPCpid),
8b649d8c 383 fProbBayes(0.0),
86a97121 384 fCurrCentr(0.0),
c27333c2 385 fVZEROgainEqualization(NULL),
86a97121 386 fApplyRecentering(that.fApplyRecentering),
043e9010 387 fVZEROgainEqualizationPerRing(that.fVZEROgainEqualizationPerRing),
84b44ed4 388 fChi2A(0x0),
389 fChi2C(0x0),
390 fChi3A(0x0),
391 fChi3C(0x0),
043e9010 392 fPIDResponse(that.fPIDResponse),
393 fNsigmaCut2(that.fNsigmaCut2)
daf66719 394{
395 //copy constructor
32b846cd 396 if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts));
397 if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts));
441ea1cf 398 if (that.fAliESDtrackCuts) fAliESDtrackCuts = new AliESDtrackCuts(*(that.fAliESDtrackCuts));
2e5052c5 399 if (that.fMuonTrackCuts) fMuonTrackCuts = new AliMuonTrackCuts(*(that.fMuonTrackCuts)); // XZhang 20120604
422c61c7 400 SetPriors(); //init arrays
1a80f9f6 401 if (that.fQA) DefineHistograms();
84b44ed4 402 // would be neater via copy ctor of TArrayD
403 fChi2A = new TArrayD(that.fChi2A->GetSize(), that.fChi2A->GetArray());
404 fChi2C = new TArrayD(that.fChi2C->GetSize(), that.fChi2C->GetArray());
405 fChi3A = new TArrayD(that.fChi3A->GetSize(), that.fChi3A->GetArray());
406 fChi3C = new TArrayD(that.fChi3C->GetSize(), that.fChi3C->GetArray());
9126fd0c 407 // New PID procedure (Bayesian Combined PID)
62f2ea04 408 fBayesianResponse = new AliFlowBayesianPID();
409 fBayesianResponse->SetNewTrackParam();
86a97121 410
c27333c2
MK		 411 // VZERO gain calibration
412 // no reason to init fVZEROgainEqualizationPerRing, will be initialized on node if necessary
86a97121 413 // pointer is set to NULL in initialization list of this constructor
c27333c2 414// if (that.fVZEROgainEqualization) fVZEROgainEqualization = new TH1(*(that.fVZEROgainEqualization));
86a97121 415 for(Int_t i(0); i < 4; i++) { // no use to copy these guys since they're only initialized on worked node
c27333c2
MK		 416 fVZEROApol[i] = 0.;
417 fVZEROCpol[i] = 0.;
86a97121 418 }
419 for(Int_t i(0); i < 8; i++) fUseVZERORing[i] = that.fUseVZERORing[i];
420
daf66719 421}
422
423//-----------------------------------------------------------------------
ee242db3 424AliFlowTrackCuts& AliFlowTrackCuts::operator=(const AliFlowTrackCuts& that)
daf66719 425{
426 //assignment
cdc20344 427 if (this==&that) return *this;
428
ee242db3 429 AliFlowTrackSimpleCuts::operator=(that);
1a80f9f6 430 //the following may seem excessive but if AliESDtrackCuts properly does copy and clone
431 //this approach is better memory-fragmentation-wise in some cases
432 if (that.fAliESDtrackCuts && fAliESDtrackCuts) *fAliESDtrackCuts=*(that.fAliESDtrackCuts);
433 if (that.fAliESDtrackCuts && !fAliESDtrackCuts) fAliESDtrackCuts=new AliESDtrackCuts(*(that.fAliESDtrackCuts));
434 if (!that.fAliESDtrackCuts) delete fAliESDtrackCuts; fAliESDtrackCuts=NULL;
2e5052c5 435
436 if ( that.fMuonTrackCuts && fMuonTrackCuts) *fMuonTrackCuts = *(that.fMuonTrackCuts); // XZhang 20120604
52990716 437 if ( that.fMuonTrackCuts && !fMuonTrackCuts) fMuonTrackCuts = new AliMuonTrackCuts(*(that.fMuonTrackCuts)); // XZhang 20120604
2e5052c5 438 if (!that.fMuonTrackCuts) delete fMuonTrackCuts; fMuonTrackCuts = NULL; // XZhang 20120604
c27333c2 439 if (!that.fVZEROgainEqualization) delete fVZEROgainEqualization; fVZEROgainEqualization = NULL;
1a80f9f6 440 //these guys we don't need to copy, just reinit
441 if (that.fQA) {fQA->Delete(); delete fQA; fQA=NULL; DefineHistograms();}
1ff4bda1 442 fCutMC=that.fCutMC;
f21bdf48 443 fCutMChasTrackReferences=that.fCutMChasTrackReferences;
ee242db3 444 fCutMCprocessType=that.fCutMCprocessType;
445 fMCprocessType=that.fMCprocessType;
446 fCutMCPID=that.fCutMCPID;
447 fMCPID=that.fMCPID;
2ed97fda 448 fCutMCfirstMotherPID=that.fCutMCfirstMotherPID;
449 fMCfirstMotherPID=that.fMCfirstMotherPID;
a14b8f3c 450 fIgnoreSignInMCPID=that.fIgnoreSignInMCPID,
ee242db3 451 fCutMCisPrimary=that.fCutMCisPrimary;
441ea1cf 452 fRequireTransportBitForPrimaries=that.fRequireTransportBitForPrimaries;
ee242db3 453 fMCisPrimary=that.fMCisPrimary;
454 fRequireCharge=that.fRequireCharge;
455 fFakesAreOK=that.fFakesAreOK;
456 fCutSPDtrackletDeltaPhi=that.fCutSPDtrackletDeltaPhi;
457 fSPDtrackletDeltaPhiMax=that.fSPDtrackletDeltaPhiMax;
458 fSPDtrackletDeltaPhiMin=that.fSPDtrackletDeltaPhiMin;
1ff4bda1 459 fIgnoreTPCzRange=that.fIgnoreTPCzRange;
460 fIgnoreTPCzRangeMax=that.fIgnoreTPCzRangeMax;
461 fIgnoreTPCzRangeMin=that.fIgnoreTPCzRangeMin;
2948ac5a 462 fCutChi2PerClusterTPC=that.fCutChi2PerClusterTPC;
463 fMaxChi2PerClusterTPC=that.fMaxChi2PerClusterTPC;
464 fMinChi2PerClusterTPC=that.fMinChi2PerClusterTPC;
32b846cd 465 fCutNClustersTPC=that.fCutNClustersTPC;
466 fNClustersTPCMax=that.fNClustersTPCMax;
467 fNClustersTPCMin=that.fNClustersTPCMin;
42655d16 468 fCutNClustersITS=that.fCutNClustersITS;
469 fNClustersITSMax=that.fNClustersITSMax;
470 fNClustersITSMin=that.fNClustersITSMin;
a63303bd 471 fUseAODFilterBit=that.fUseAODFilterBit;
472 fAODFilterBit=that.fAODFilterBit;
473 fCutDCAToVertexXY=that.fCutDCAToVertexXY;
474 fCutDCAToVertexZ=that.fCutDCAToVertexZ;
2b1eaa10 475 fCutMinimalTPCdedx=that.fCutMinimalTPCdedx;
476 fMinimalTPCdedx=that.fMinimalTPCdedx;
92b507bb 477 fLinearizeVZEROresponse=that.fLinearizeVZEROresponse;
1a80f9f6 478 fCutPmdDet=that.fCutPmdDet;
479 fPmdDet=that.fPmdDet;
480 fCutPmdAdc=that.fCutPmdAdc;
481 fPmdAdc=that.fPmdAdc;
482 fCutPmdNcell=that.fCutPmdNcell;
483 fPmdNcell=that.fPmdNcell;
dd294bb6
MK		 484 fMinKinkAngle=that.fMinKinkAngle;
485 fMinKinkRadius=that.fMinKinkRadius;
486 fMaxKinkRadius=that.fMaxKinkRadius;
487 fMinKinkQt=that.fMinKinkQt;
488 fMaxKinkQt=that.fMaxKinkQt;
489 fMinKinkInvMassKmu=that.fMinKinkInvMassKmu;
490 fMaxKinkInvMassKmu=that.fMaxKinkInvMassKmu;
491 fForceTPCstandalone=that.fForceTPCstandalone;
492 fRequireKinkDaughters=that.fRequireKinkDaughters;
1a80f9f6 493
ee242db3 494 fParamType=that.fParamType;
495 fParamMix=that.fParamMix;
daf66719 496
dd294bb6
MK		 497 fKink=NULL;
498 fV0=NULL;
daf66719 499 fTrack=NULL;
dd294bb6
MK		 500 fTrackMass=0.;
501 fTrackPt=0.;
1a80f9f6 502 fTrackEta=0.;
ee242db3 503 fTrackPhi=0.;
2281e7c5 504 fTrackWeight=1.;
127a5825 505 fTrackLabel=INT_MIN;
957517fa 506 fMCevent=NULL;
daf66719 507 fMCparticle=NULL;
9a0783cc 508 fEvent=NULL;
daf66719 509
32b846cd 510 fESDpid = that.fESDpid;
511 fPIDsource = that.fPIDsource;
512
cdc20344 513 delete fTPCpidCuts;
514 delete fTOFpidCuts;
32b846cd 515 if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts));
516 if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts));
32b846cd 517
2b1eaa10 518 fParticleID=that.fParticleID;
519 fParticleProbability=that.fParticleProbability;
875ee12a 520 fAllowTOFmismatchFlag=that.fAllowTOFmismatchFlag;
521 fRequireStrictTOFTPCagreement=that.fRequireStrictTOFTPCagreement;
0b14d0f4 522 fCutRejectElectronsWithTPCpid=that.fCutRejectElectronsWithTPCpid;
8b649d8c 523 fProbBayes = that.fProbBayes;
9126fd0c 524 fCurrCentr = that.fCurrCentr;
86a97121 525
526 fApplyRecentering = that.fApplyRecentering;
c27333c2 527 fVZEROgainEqualizationPerRing = that.fVZEROgainEqualizationPerRing;
93ec5f2f 528#if ROOT_VERSION_CODE < ROOT_VERSION(5,99,0)
c27333c2 529 if (that.fVZEROgainEqualization) fVZEROgainEqualization = new TH1(*(that.fVZEROgainEqualization));
93ec5f2f 530#else
531 //PH Lets try Clone, however the result might be wrong
c27333c2 532 if (that.fVZEROgainEqualization) fVZEROgainEqualization = (TH1*)that.fVZEROgainEqualization->Clone();
93ec5f2f 533#endif
86a97121 534 for(Int_t i(0); i < 4; i++) { // no use to copy these guys since they're only initialized on worked node
c27333c2
MK		 535 fVZEROApol[i] = that.fVZEROApol[i];
536 fVZEROCpol[i] = that.fVZEROCpol[i];
86a97121 537 }
538 for(Int_t i(0); i < 8; i++) fUseVZERORing[i] = that.fUseVZERORing[i];
84b44ed4 539 // would be neater via copy ctor of TArrayD
540 fChi2A = new TArrayD(that.fChi2A->GetSize(), that.fChi2A->GetArray());
541 fChi2C = new TArrayD(that.fChi2C->GetSize(), that.fChi2C->GetArray());
542 fChi3A = new TArrayD(that.fChi3A->GetSize(), that.fChi3A->GetArray());
543 fChi3C = new TArrayD(that.fChi3C->GetSize(), that.fChi3C->GetArray());
9126fd0c 544
043e9010 545 fPIDResponse = that.fPIDResponse;
546 fNsigmaCut2 = that.fNsigmaCut2;
547
daf66719 548 return *this;
549}
550
551//-----------------------------------------------------------------------
552AliFlowTrackCuts::~AliFlowTrackCuts()
553{
554 //dtor
daf66719 555 delete fAliESDtrackCuts;
32b846cd 556 delete fTPCpidCuts;
557 delete fTOFpidCuts;
2e5052c5 558 if (fMuonTrackCuts) delete fMuonTrackCuts; // XZhang 20120604
499fe731 559 if (fQA) { fQA->SetOwner(); fQA->Delete(); delete fQA; }
84b44ed4 560 if (fVZEROgainEqualization) {
561 delete fVZEROgainEqualization;
562 fVZEROgainEqualization = 0x0;
563 }
564 if(fChi2A) {
565 delete fChi2A;
566 fChi2A = 0x0;
567 }
568 if(fChi3A) {
569 delete fChi3A;
570 fChi3A = 0x0;
571 }
572 if(fChi2C) {
573 delete fChi2C;
574 fChi2C = 0x0;
575 }
576 if(fChi3C) {
577 delete fChi3C;
578 fChi3C = 0x0;
579 }
daf66719 580}
581
aab6527a 582//-----------------------------------------------------------------------
583void AliFlowTrackCuts::SetEvent(AliVEvent* event, AliMCEvent* mcEvent)
584{
585 //set the event
586 Clear();
587 fEvent=event;
588 fMCevent=mcEvent;
589
043e9010 590 // Get PID response
591 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
592 if(man){
593 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
594 if(inputHandler) fPIDResponse=inputHandler->GetPIDResponse();
595 }
596
aab6527a 597 //do the magic for ESD
598 AliESDEvent* myESD = dynamic_cast<AliESDEvent*>(event);
0d16f553 599 AliAODEvent* myAOD = dynamic_cast<AliAODEvent*>(event);
aab6527a 600 if (fCutPID && myESD)
601 {
602 //TODO: maybe call it only for the TOF options?
603 // Added by F. Noferini for TOF PID
9126fd0c 604 // old procedure now implemented inside fBayesianResponse
605 // fESDpid.MakePID(myESD,kFALSE);
606 // new procedure
607 fBayesianResponse->SetDetResponse(myESD, fCurrCentr,AliESDpid::kTOF_T0,kTRUE); // centrality = PbPb centrality class (0-100%) or -1 for pp collisions
aab6527a 608 fESDpid.SetTOFResponse(myESD,AliESDpid::kTOF_T0);
aab6527a 609 // End F. Noferini added part
610 }
0d16f553 611 if (fCutPID && myAOD){
612 fBayesianResponse->SetDetResponse(myAOD, fCurrCentr,AliESDpid::kTOF_T0); // centrality = PbPb centrality class (0-100%) or -1 for pp collisions
613 if(myAOD->GetTOFHeader()){
614 fESDpid.SetTOFResponse(myAOD,AliESDpid::kTOF_T0);
615 }
616 else{ // corrected on the fly track by track if tof header is not present (old AODs)
617 }
618 // End F. Noferini added part
619 }
620
621 if(fPIDsource==kTOFbayesian) fBayesianResponse->SetDetAND(1);
622 else if(fPIDsource==kTPCbayesian) fBayesianResponse->ResetDetOR(1);
aab6527a 623}
624
625//-----------------------------------------------------------------------
626void AliFlowTrackCuts::SetCutMC( Bool_t b )
627{
628 //will we be cutting on MC information?
629 fCutMC=b;
630
631 //if we cut on MC info then also the Bethe Bloch should be the one tuned for MC
632 if (fCutMC)
633 {
634 fESDpid.GetTPCResponse().SetBetheBlochParameters( 2.15898e+00/50.,
635 1.75295e+01,
636 3.40030e-09,
637 1.96178e+00,
638 3.91720e+00);
639 }
640}
641
daf66719 642//-----------------------------------------------------------------------
12b2b8bc 643Bool_t AliFlowTrackCuts::IsSelected(TObject* obj, Int_t id)
daf66719 644{
cac040c5 645 //check cuts
daf66719 646 AliVParticle* vparticle = dynamic_cast<AliVParticle*>(obj);
2e5052c5 647//if (vparticle) return PassesCuts(vparticle); // XZhang 20120604
648 if (vparticle) { // XZhang 20120604
649 if (fParamType==kMUON) return PassesMuonCuts(vparticle); // XZhang 20120604
650 return PassesCuts(vparticle); // XZhang 20120604
651 } // XZhang 20120604
4aae2a93 652
daf66719 653 AliFlowTrackSimple* flowtrack = dynamic_cast<AliFlowTrackSimple*>(obj);
654 if (flowtrack) return PassesCuts(flowtrack);
12b2b8bc 655 AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj);
656 if (tracklets) return PassesCuts(tracklets,id);
2e5052c5 657 AliAODTracklets* trkletAOD = dynamic_cast<AliAODTracklets*>(obj); // XZhang 20120615
658 if (trkletAOD) return PassesCuts(trkletAOD,id); // XZhang 20120615
d148af7e 659 AliESDPmdTrack* pmdtrack = dynamic_cast<AliESDPmdTrack*>(obj);
660 if (pmdtrack) return PassesPMDcuts(pmdtrack);
3cca9bf4 661 AliVVZERO* vvzero = dynamic_cast<AliVVZERO*>(obj); // downcast to base class
c27333c2 662 if (vvzero) return PassesVZEROcuts(id);
dd294bb6
MK		 663 AliESDkink* kink = dynamic_cast<AliESDkink*>(obj);
664 if (kink) return PassesCuts(kink);
665 //AliESDv0* v0 = dynamic_cast<AliESDv0*>(obj);
666 //if (v0) return PassesCuts(v0);
3cca9bf4 667
daf66719 668 return kFALSE; //default when passed wrong type of object
669}
670
1ff4bda1 671//-----------------------------------------------------------------------
672Bool_t AliFlowTrackCuts::IsSelectedMCtruth(TObject* obj, Int_t id)
673{
674 //check cuts
675 AliVParticle* vparticle = dynamic_cast<AliVParticle*>(obj);
676 if (vparticle)
677 {
2281e7c5 678 return PassesMCcuts(fMCevent,(fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel());
1ff4bda1 679 }
680 AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj);
681 if (tracklets)
682 {
683 Int_t label0 = tracklets->GetLabel(id,0);
684 Int_t label1 = tracklets->GetLabel(id,1);
2281e7c5 685 Int_t label = (fFakesAreOK)?TMath::Abs(label0):label0;
686 if (label0!=label1) label = -666;
1ff4bda1 687 return PassesMCcuts(fMCevent,label);
688 }
689 return kFALSE; //default when passed wrong type of object
690}
691
daf66719 692//-----------------------------------------------------------------------
1a80f9f6 693Bool_t AliFlowTrackCuts::PassesCuts(const AliFlowTrackSimple* track)
daf66719 694{
695 //check cuts on a flowtracksimple
5559ce24 696
697 //clean up from last iteration
dd294bb6 698 ClearTrack();
daf66719 699 return AliFlowTrackSimpleCuts::PassesCuts(track);
700}
701
12b2b8bc 702//-----------------------------------------------------------------------
1a80f9f6 703Bool_t AliFlowTrackCuts::PassesCuts(const AliMultiplicity* tracklet, Int_t id)
12b2b8bc 704{
705 //check cuts on a tracklets
706
b35580e6 707 if (id<0) return kFALSE;
708
9a0783cc 709 //clean up from last iteration, and init label
dd294bb6 710 ClearTrack();
12b2b8bc 711
712 fTrackPhi = tracklet->GetPhi(id);
713 fTrackEta = tracklet->GetEta(id);
714 fTrackWeight = 1.0;
715 if (fCutEta) {if ( fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) return kFALSE;}
716 if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) return kFALSE;}
717
718 //check MC info if available
9a0783cc 719 //if the 2 clusters have different label track cannot be good
720 //and should therefore not pass the mc cuts
721 Int_t label0 = tracklet->GetLabel(id,0);
722 Int_t label1 = tracklet->GetLabel(id,1);
d0471ea0 723 //if possible get label and mcparticle
9a0783cc 724 fTrackLabel = (label0==label1)?tracklet->GetLabel(id,1):-1;
7afa829c 725 if (!fFakesAreOK && fTrackLabel<0) return kFALSE;
d0471ea0 726 if (fTrackLabel>=0 && fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
727 //check MC cuts
1ff4bda1 728 if (fCutMC && !PassesMCcuts()) return kFALSE;
12b2b8bc 729 return kTRUE;
730}
731
2e5052c5 732//-----------------------------------------------------------------------
733Bool_t AliFlowTrackCuts::PassesCuts(const AliAODTracklets* tracklet, Int_t id)
734{
735 // XZhang 20120615
736 //check cuts on a tracklets
737
738 if (id<0) return kFALSE;
739
740 //clean up from last iteration, and init label
dd294bb6 741 ClearTrack();
2e5052c5 742
743 fTrackPhi = tracklet->GetPhi(id);
744//fTrackEta = tracklet->GetEta(id);
745 fTrackEta = -1.*TMath::Log(TMath::Tan(tracklet->GetTheta(id)/2.));
746 fTrackWeight = 1.0;
747 if (fCutEta) {if ( fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) return kFALSE;}
748 if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) return kFALSE;}
749
750 //check MC info if available
751 //if the 2 clusters have different label track cannot be good
752 //and should therefore not pass the mc cuts
753 Int_t label0 = tracklet->GetLabel(id,0);
754 Int_t label1 = tracklet->GetLabel(id,1);
755 //if possible get label and mcparticle
756 fTrackLabel = (label0==label1)?tracklet->GetLabel(id,1):-1;
757 if (!fFakesAreOK && fTrackLabel<0) return kFALSE;
758 if (fTrackLabel>=0 && fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
759 //check MC cuts
760 if (fCutMC && !PassesMCcuts()) return kFALSE;
761 return kTRUE;
762}
763
12b2b8bc 764//-----------------------------------------------------------------------
1ff4bda1 765Bool_t AliFlowTrackCuts::PassesMCcuts(AliMCEvent* mcEvent, Int_t label)
12b2b8bc 766{
767 //check the MC info
1ff4bda1 768 if (!mcEvent) return kFALSE;
769 if (label<0) return kFALSE;//otherwise AliCMevent prints a warning before returning NULL
770 AliMCParticle* mcparticle = static_cast<AliMCParticle*>(mcEvent->GetTrack(label));
771 if (!mcparticle) {AliError("no MC track"); return kFALSE;}
12b2b8bc 772
773 if (fCutMCisPrimary)
774 {
441ea1cf 775 if (IsPhysicalPrimary(mcEvent,label,fRequireTransportBitForPrimaries) != fMCisPrimary) return kFALSE;
12b2b8bc 776 }
777 if (fCutMCPID)
778 {
1ff4bda1 779 Int_t pdgCode = mcparticle->PdgCode();
a14b8f3c 780 if (fIgnoreSignInMCPID)
4cbcbead 781 {
782 if (TMath::Abs(fMCPID) != TMath::Abs(pdgCode)) return kFALSE;
783 }
784 else
785 {
786 if (fMCPID != pdgCode) return kFALSE;
787 }
12b2b8bc 788 }
2ed97fda 789 if (fCutMCfirstMotherPID)
790 {
791
792 TParticle* tparticle=mcparticle->Particle();
793 Int_t firstMotherLabel = 0;
794 if (tparticle) { firstMotherLabel = tparticle->GetFirstMother(); }
795 AliVParticle* firstMotherParticle = mcEvent->GetTrack(firstMotherLabel);
796 Int_t pdgcodeFirstMother = 0;
797 if (firstMotherParticle) { pdgcodeFirstMother = firstMotherParticle->PdgCode(); }
798 if (pdgcodeFirstMother != fMCfirstMotherPID) return kFALSE;
799 }
12b2b8bc 800 if ( fCutMCprocessType )
801 {
1ff4bda1 802 TParticle* particle = mcparticle->Particle();
12b2b8bc 803 Int_t processID = particle->GetUniqueID();
804 if (processID != fMCprocessType ) return kFALSE;
805 }
f21bdf48 806 if (fCutMChasTrackReferences)
807 {
808 if (mcparticle->GetNumberOfTrackReferences()<1) return kFALSE;
809 }
12b2b8bc 810 return kTRUE;
811}
1a80f9f6 812
1ff4bda1 813//-----------------------------------------------------------------------
814Bool_t AliFlowTrackCuts::PassesMCcuts()
815{
1a80f9f6 816 //check MC info
1ff4bda1 817 if (!fMCevent) return kFALSE;
818 if (fTrackLabel<0) return kFALSE;//otherwise AliCMevent prints a warning before returning NULL
819 fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
820 return PassesMCcuts(fMCevent,fTrackLabel);
821}
12b2b8bc 822
dd294bb6
MK		 823//-----------------------------------------------------------------------
824Bool_t AliFlowTrackCuts::PassesCuts(const AliESDv0* v0)
825{
826 //check if the v0 passes cuts
827
828 //clean up from last iteration
829 ClearTrack();
830
831 fV0 = const_cast<AliESDv0*>(v0);
832
833 Bool_t pass = kTRUE;
834
835 //first, extract/prepare the v0
836 if (!v0->GetOnFlyStatus()) return kFALSE; //skip offline V0 finder
837 const AliExternalTrackParam *negHelix=v0->GetParamN();
838 const AliExternalTrackParam *posHelix=v0->GetParamP();
839 AliVParticle *v0tracks[2];
840 v0tracks[0] = fEvent->GetTrack(v0->GetNindex());
841 v0tracks[1] = fEvent->GetTrack(v0->GetPindex());
842 if( v0tracks[1]->Charge() < 0)
843 {
844 v0tracks[1] = fEvent->GetTrack(v0->GetNindex());
845 v0tracks[0] = fEvent->GetTrack(v0->GetPindex());
846 negHelix=v0->GetParamP();
847 posHelix=v0->GetParamN();
848 }
849
850 int KalmanPidPairs[4][2] =
851 {
852 {-11,11}, // e-,e+ (gamma)
853 {-211,2212}, // pi- p (lambda)
854 {-2212,211}, // anti-p pi+ (anti-lambda)
855 {-211,211} // pi- pi+ (Kshort)
856 // {-321,321} // K- K+ (phi)
857 };
858
859 Int_t id = 3;
860 //refit using a mass hypothesis
861 AliKFParticle v0trackKFneg(*(negHelix),KalmanPidPairs[id][0]);
862 AliKFParticle v0trackKFpos(*(posHelix),KalmanPidPairs[id][1]);
863 AliKFParticle v0particleRefit;
864 v0particleRefit += v0trackKFneg;
865 v0particleRefit += v0trackKFpos;
866 Double_t invMassErr= -999;
867 v0particleRefit.GetMass(fTrackMass,invMassErr);
868 //Double_t openAngle = v0trackKFneg.GetAngle(v0trackKFpos);
869 fTrackEta = v0particleRefit.GetEta();
870 fTrackPt = v0particleRefit.GetPt();
871 fTrackPhi = TMath::Pi()+v0particleRefit.GetPhi();
872 ////find out which mass bin and put the number in fPOItype
873 //Int_t massBins = AliFlowCommonConstants::GetMaster()->GetNbinsMass();
874 //Double_t massMin = AliFlowCommonConstants::GetMaster()->GetMassMin();
875 //Double_t massMax = AliFlowCommonConstants::GetMaster()->GetMassMax();
876 //fPOItype = 1 + int(massBins*(fTrackMass-massMin)/(massMax-massMin));
877
878 /////////////////////////////////////////////////////////////////////////////
879 //apply cuts
880 if ( v0tracks[0]->Charge() == v0tracks[1]->Charge() ) pass=kFALSE;
881 if ( v0tracks[0]->Pt()<0.15 || v0tracks[1]->Pt()<0.15 ) pass=kFALSE;
882
883 return pass;
884}
885
886//-----------------------------------------------------------------------
887Bool_t AliFlowTrackCuts::PassesCuts(const AliESDkink* kink)
888{
889 //check if the kink passes cuts
890
891 //clean up from last iteration
892 ClearTrack();
893 fKink=const_cast<AliESDkink*>(kink);
894
895 Bool_t pass = kTRUE;
896
897 Float_t kinkAngle = kink->GetAngle(2);
898 if (kinkAngle<fMinKinkAngle) pass = kFALSE;
899 Double_t kinkRadius = kink->GetR();
900 if (kinkRadius<fMinKinkRadius || kinkRadius>fMaxKinkRadius) pass = kFALSE;
901
902 //Qt
903 const TVector3 motherMfromKink(kink->GetMotherP());
904 const TVector3 daughterMfromKink(kink->GetDaughterP());
905 Float_t qt=kink->GetQt();
906 if ( qt < fMinKinkQt || qt > fMaxKinkQt) pass = kFALSE;
907
908 //invariant mass
909 Float_t energyDaughterMu = TMath::Sqrt( daughterMfromKink.Mag()*daughterMfromKink.Mag()+
910 0.105658*0.105658 );
911 Float_t p1XM = motherMfromKink.Px();
912 Float_t p1YM = motherMfromKink.Py();
913 Float_t p1ZM = motherMfromKink.Pz();
914 Float_t p2XM = daughterMfromKink.Px();
915 Float_t p2YM = daughterMfromKink.Py();
916 Float_t p2ZM = daughterMfromKink.Pz();
917 Float_t p3Daughter = TMath::Sqrt( ((p1XM-p2XM)*(p1XM-p2XM))+((p1YM-p2YM)*(p1YM-p2YM))+
918 ((p1ZM-p2ZM)*(p1ZM-p2ZM)) );
919 Double_t invariantMassKmu = TMath::Sqrt( (energyDaughterMu+p3Daughter)*(energyDaughterMu+p3Daughter)-
920 motherMfromKink.Mag()*motherMfromKink.Mag() );
921 if (invariantMassKmu > fMaxKinkInvMassKmu) pass=kFALSE;
922 if (invariantMassKmu < fMinKinkInvMassKmu) pass=kFALSE;
923 fTrackMass=invariantMassKmu;
924
925 if (fQA)
926 {
927 QAbefore(13)->Fill(qt);
928 if (pass) QAafter(13)->Fill(qt);
929 QAbefore(14)->Fill(invariantMassKmu);
930 if (pass) QAafter(14)->Fill(invariantMassKmu);
931 const Double_t* kinkPosition = kink->GetPosition();
932 QAbefore(15)->Fill(kinkPosition[0],kinkPosition[1]);
933 if (pass) QAafter(15)->Fill(kinkPosition[0],kinkPosition[1]);
934 QAbefore(16)->Fill(motherMfromKink.Mag(),kinkAngle*TMath::RadToDeg());
935 if (pass) QAafter(16)->Fill(motherMfromKink.Mag(),kinkAngle*TMath::RadToDeg());
936 }
937
938 //mother track cuts
939 Int_t indexKinkMother = kink->GetIndex(0);
940 AliESDtrack* motherTrack = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(indexKinkMother));
941 if (!motherTrack) return kFALSE;
942 if (!PassesCuts(motherTrack)) pass = kFALSE;
943
944 return pass;
945}
946
daf66719 947//-----------------------------------------------------------------------
948Bool_t AliFlowTrackCuts::PassesCuts(AliVParticle* vparticle)
949{
950 //check cuts for an ESD vparticle
951
127a5825 952 ////////////////////////////////////////////////////////////////
953 // start by preparing the track parameters to cut on //////////
954 ////////////////////////////////////////////////////////////////
5559ce24 955 //clean up from last iteration
dd294bb6
MK		 956 ClearTrack();
957 Bool_t pass=kTRUE;
5559ce24 958
957517fa 959 //get the label and the mc particle
127a5825 960 fTrackLabel = (fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel();
961 if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
daf66719 962 else fMCparticle=NULL;
963
957517fa 964 Bool_t isMCparticle = kFALSE; //some things are different for MC particles, check!
daf66719 965 AliESDtrack* esdTrack = dynamic_cast<AliESDtrack*>(vparticle);
42655d16 966 AliAODTrack* aodTrack = NULL;
daf66719 967 if (esdTrack)
7d27a354 968 {
42655d16 969 //for an ESD track we do some magic sometimes like constructing TPC only parameters
970 //or doing some hybrid, handle that here
daf66719 971 HandleESDtrack(esdTrack);
7d27a354 972 }
daf66719 973 else
957517fa 974 {
daf66719 975 HandleVParticle(vparticle);
957517fa 976 //now check if produced particle is MC
977 isMCparticle = (dynamic_cast<AliMCParticle*>(fTrack))!=NULL;
42655d16 978 aodTrack = dynamic_cast<AliAODTrack*>(vparticle); //keep the additional dynamic cast out of the way for ESDs
957517fa 979 }
127a5825 980 ////////////////////////////////////////////////////////////////
981 ////////////////////////////////////////////////////////////////
982
1ff4bda1 983 if (!fTrack) return kFALSE;
42655d16 984 //because it may be different from global, not needed for aodTrack because we dont do anything funky there
985 if (esdTrack) esdTrack = static_cast<AliESDtrack*>(fTrack);
2948ac5a 986
9a0783cc 987 //check the common cuts for the current particle fTrack (MC,AOD,ESD)
32b846cd 988 Double_t pt = fTrack->Pt();
f21bdf48 989 Double_t p = fTrack->P();
7afa829c 990 if (!fFakesAreOK) {if (fTrackLabel<0) pass=kFALSE;}
32b846cd 991 if (fCutPt) {if (pt < fPtMin || pt >= fPtMax ) pass=kFALSE;}
924b02b0 992 if (fCutEta) {if (fTrack->Eta() < fEtaMin || fTrack->Eta() >= fEtaMax ) pass=kFALSE;}
993 if (fCutPhi) {if (fTrack->Phi() < fPhiMin || fTrack->Phi() >= fPhiMax ) pass=kFALSE;}
994 if (fRequireCharge) {if (fTrack->Charge() == 0) pass=kFALSE;}
995 if (fCutCharge && !isMCparticle) {if (fTrack->Charge() != fCharge) pass=kFALSE;}
957517fa 996 if (fCutCharge && isMCparticle)
997 {
998 //in case of an MC particle the charge is stored in units of 1/3|e|
999 Int_t charge = TMath::Nint(fTrack->Charge()/3.0); //mc particles have charge in units of 1/3e
32b846cd 1000 if (charge!=fCharge) pass=kFALSE;
957517fa 1001 }
924b02b0 1002 //if(fCutPID) {if (fTrack->PID() != fPID) pass=kFALSE;}
daf66719 1003
957517fa 1004 //when additionally MC info is required
1ff4bda1 1005 if (fCutMC && !PassesMCcuts()) pass=kFALSE;
daf66719 1006
42655d16 1007 //the case of ESD or AOD
bb6ca457 1008 if (esdTrack) { if (!PassesESDcuts(esdTrack)) { pass=kFALSE; } }
60875c3c 1009 if (aodTrack) { if (!PassesAODcuts(aodTrack,pass)) { pass=kFALSE; } }
42655d16 1010
f21bdf48 1011 if (fQA)
1012 {
c3eb0b6c 1013 if (fMCparticle)
f21bdf48 1014 {
875ee12a 1015 TParticle* tparticle=fMCparticle->Particle();
1016 Int_t processID = tparticle->GetUniqueID();
8eca5d19 1017 Int_t firstMotherLabel = tparticle->GetFirstMother();
3c67c769 1018 Bool_t primary = IsPhysicalPrimary();
875ee12a 1019 //TLorentzVector v;
1020 //mcparticle->Particle()->ProductionVertex(v);
1021 //Double_t prodvtxX = v.X();
1022 //Double_t prodvtxY = v.Y();
1023
c3eb0b6c 1024 Int_t pdgcode = fMCparticle->PdgCode();
483a17da 1025 AliVParticle* firstMotherParticle = fMCevent->GetTrack(firstMotherLabel);
1026 Int_t pdgcodeFirstMother = 0;
1027 if (firstMotherParticle) {pdgcodeFirstMother = firstMotherParticle->PdgCode();}
8eca5d19 1028
483a17da 1029 Float_t pdg = 0;
c3eb0b6c 1030 switch (TMath::Abs(pdgcode))
1031 {
1032 case 11:
1033 pdg = AliPID::kElectron + 0.5; break;
1034 case 13:
1035 pdg = AliPID::kMuon + 0.5; break;
1036 case 211:
1037 pdg = AliPID::kPion + 0.5; break;
1038 case 321:
1039 pdg = AliPID::kKaon + 0.5; break;
1040 case 2212:
1041 pdg = AliPID::kProton + 0.5; break;
1042 default:
1043 pdg = AliPID::kUnknown + 0.5; break;
1044 }
1045 pdg = TMath::Sign(pdg,static_cast<Float_t>(pdgcode));
8eca5d19 1046
2281e7c5 1047 Float_t geantCode = 0;
1048 switch (pdgcodeFirstMother)
8eca5d19 1049 {
2281e7c5 1050 case 22: //#gamma
1051 geantCode=1;
0284e4ef 1052 break;
2281e7c5 1053 case -11: //e^{+}
1054 geantCode=2;
0284e4ef 1055 break;
2281e7c5 1056 case 11: //e^{-}
1057 geantCode=3;
0284e4ef 1058 break;
2281e7c5 1059 case 12: case 14: case 16: //#nu
1060 geantCode=4;
1061 break;
1062 case -13:
1063 geantCode=5; //#mu^{+}
1064 break;
1065 case 13:
1066 geantCode=6; //#mu^{-}
1067 break;
1068 case 111: //#pi^{0}
1069 geantCode=7;
1070 break;
1071 case 211: //#pi^{+}
1072 geantCode=8;
1073 break;
1074 case -211: //#pi^{-}
1075 geantCode=9;
1076 break;
1077 case 130: //K^{0}_{L}
1078 geantCode=10;
1079 break;
1080 case 321: //K^{+}
1081 geantCode=11;
1082 break;
1083 case -321: //K^{-}
1084 geantCode=12;
1085 break;
1086 case 2112:
1087 geantCode = 13; //n
1088 break;
1089 case 2212:
1090 geantCode = 14; //p
1091 break;
1092 case -2212:
1093 geantCode=15; //#bar{p}
1094 break;
1095 case 310:
1096 geantCode=16; //K^{0}_{S}
1097 break;
1098 case 221:
1099 geantCode=17; //#eta
1100 break;
1101 case 3122:
1102 geantCode=18; //#Lambda
1103 break;
1104 case 3222:
1105 geantCode=19; //#Sigma^{+}
1106 break;
1107 case 3212:
1108 geantCode=20; //#Sigma^{0}
1109 break;
1110 case 3112:
1111 geantCode=21; //#Sigma^{-}
1112 break;
1113 case 3322:
1114 geantCode=22; //#Theta^{0}
1115 break;
1116 case 3312:
1117 geantCode=23; //#Theta^{-}
1118 break;
1119 case 3332:
1120 geantCode=24; //#Omega^{-}
1121 break;
1122 case -2112:
1123 geantCode=25; //#bar{n}
1124 break;
1125 case -3122:
1126 geantCode=26; //#bar{#Lambda}
1127 break;
1128 case -3112:
1129 geantCode=27; //#bar{#Sigma}^{-}
1130 break;
1131 case -3212:
1132 geantCode=28; //#bar{#Sigma}^{0}
1133 break;
1134 case -3222:
1135 geantCode=29; //#bar{#Sigma}^{+}
1136 break;
1137 case -3322:
1138 geantCode=30; //#bar{#Theta}^{0}
1139 break;
1140 case -3312:
1141 geantCode=31; //#bar{#Theta}^{+}
1142 break;
1143 case -3332:
1144 geantCode=32; //#bar{#Omega}^{+}
1145 break;
1146 case -15:
1147 geantCode=33; //#tau^{+}
1148 break;
1149 case 15:
1150 geantCode=34; //#tau^{-}
1151 break;
1152 case 411:
1153 geantCode=35; //D^{+}
1154 break;
1155 case -411:
1156 geantCode=36; //D^{-}
1157 break;
1158 case 421:
1159 geantCode=37; //D^{0}
1160 break;
1161 case -421:
1162 geantCode=38; //#bar{D}^{0}
1163 break;
1164 case 431:
1165 geantCode=39; //D_{s}^{+}
1166 break;
1167 case -431:
1168 geantCode=40; //#bar{D_{s}}^{-}
1169 break;
1170 case 4122:
1171 geantCode=41; //#Lambda_{c}^{+}
1172 break;
1173 case 24:
1174 geantCode=42; //W^{+}
1175 break;
1176 case -24:
1177 geantCode=43; //W^{-}
1178 break;
1179 case 23:
1180 geantCode=44; //Z^{0}
0284e4ef 1181 break;
8eca5d19 1182 default:
2281e7c5 1183 geantCode = 100;
0284e4ef 1184 break;
8eca5d19 1185 }
8eca5d19 1186
c3eb0b6c 1187 QAbefore(2)->Fill(p,pdg);
3c67c769 1188 QAbefore(3)->Fill(p,primary?0.5:-0.5);
875ee12a 1189 QAbefore(4)->Fill(p,static_cast<Float_t>(processID));
2281e7c5 1190 QAbefore(7)->Fill(p,geantCode+0.5);
c3eb0b6c 1191 if (pass) QAafter(2)->Fill(p,pdg);
3c67c769 1192 if (pass) QAafter(3)->Fill(p,primary?0.5:-0.5);
875ee12a 1193 if (pass) QAafter(4)->Fill(p,static_cast<Float_t>(processID));
2281e7c5 1194 if (pass) QAafter(7)->Fill(p,geantCode);
f21bdf48 1195 }
f21bdf48 1196 }
1197
42655d16 1198 //true by default, if we didn't set any cuts
1199 return pass;
1200}
1201
1202//_______________________________________________________________________
60875c3c 1203Bool_t AliFlowTrackCuts::PassesAODcuts(const AliAODTrack* track, Bool_t passedFid)
42655d16 1204{
1a80f9f6 1205 //check cuts for AOD
60875c3c 1206 Bool_t pass = passedFid;
42655d16 1207
1208 if (fCutNClustersTPC)
1ff4bda1 1209 {
42655d16 1210 Int_t ntpccls = track->GetTPCNcls();
1211 if (ntpccls < fNClustersTPCMin || ntpccls > fNClustersTPCMax) pass=kFALSE;
1212 }
1213
1214 if (fCutNClustersITS)
1215 {
1216 Int_t nitscls = track->GetITSNcls();
1217 if (nitscls < fNClustersITSMin || nitscls > fNClustersITSMax) pass=kFALSE;
1218 }
5ba02b32 1219
1220 if (fCutChi2PerClusterTPC)
1221 {
1222 Double_t chi2tpc = track->Chi2perNDF();
1223 if (chi2tpc < fMinChi2PerClusterTPC || chi2tpc > fMaxChi2PerClusterTPC) pass=kFALSE;
1224 }
1225
1226 if (GetRequireTPCRefit() && !(track->GetStatus() & AliESDtrack::kTPCrefit) ) pass=kFALSE;
1227 if (GetRequireITSRefit() && !(track->GetStatus() & AliESDtrack::kITSrefit) ) pass=kFALSE;
1228
1229 if (fUseAODFilterBit && !track->TestFilterBit(fAODFilterBit)) pass=kFALSE;
1230
a63303bd 1231 if (fCutDCAToVertexXY && track->DCA()>GetMaxDCAToVertexXY()) pass=kFALSE;
42655d16 1232
8eca5d19 1233 if (fCutDCAToVertexZ && track->ZAtDCA()>GetMaxDCAToVertexZ()) pass=kFALSE;
1234
60875c3c 1235 Double_t dedx = track->GetTPCsignal();
1236 if (dedx < fMinimalTPCdedx) pass=kFALSE;
80efa607 1237 Double_t time[9];
60875c3c 1238 track->GetIntegratedTimes(time);
d0ce6147 1239 if (fCutPID && (fParticleID!=AliPID::kUnknown)) //if kUnknown don't cut on PID
1240 {
1241 if (!PassesAODpidCut(track)) pass=kFALSE;
1242 }
1243
60875c3c 1244 if (fQA) {
d0ce6147 1245 // changed 04062014 used to be filled before possible PID cut
60875c3c 1246 Double_t momTPC = track->GetTPCmomentum();
a22c1eb1 1247 QAbefore( 0)->Fill(momTPC,GetBeta(track, kTRUE));
1248 if(pass) QAafter( 0)->Fill(momTPC, GetBeta(track, kTRUE));
60875c3c 1249 QAbefore( 1)->Fill(momTPC,dedx);
1250 QAbefore( 5)->Fill(track->Pt(),track->DCA());
1251 QAbefore( 6)->Fill(track->Pt(),track->ZAtDCA());
1252 if (pass) QAafter( 1)->Fill(momTPC,dedx);
1253 if (pass) QAafter( 5)->Fill(track->Pt(),track->DCA());
1254 if (pass) QAafter( 6)->Fill(track->Pt(),track->ZAtDCA());
1255 QAbefore( 8)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kElectron]));
1256 if (pass) QAafter( 8)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kElectron]));
1257 QAbefore( 9)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kMuon]));
1258 if (pass) QAafter( 9)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kMuon]));
1259 QAbefore(10)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kPion]));
1260 if (pass) QAafter( 10)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kPion]));
1261 QAbefore(11)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kKaon]));
1262 if (pass) QAafter( 11)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kKaon]));
1263 QAbefore(12)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kProton]));
1264 if (pass) QAafter( 12)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kProton]));
1265 }
8eca5d19 1266
d0ce6147 1267
42655d16 1268 return pass;
1269}
1270
1271//_______________________________________________________________________
1272Bool_t AliFlowTrackCuts::PassesESDcuts(AliESDtrack* track)
1273{
1a80f9f6 1274 //check cuts on ESD tracks
42655d16 1275 Bool_t pass=kTRUE;
cd62a2a8 1276 Float_t dcaxy=0.0;
1277 Float_t dcaz=0.0;
1278 track->GetImpactParameters(dcaxy,dcaz);
499fe731 1279 const AliExternalTrackParam* pout = track->GetOuterParam();
1280 const AliExternalTrackParam* pin = track->GetInnerParam();
42655d16 1281 if (fIgnoreTPCzRange)
1282 {
42655d16 1283 if (pin&&pout)
441ea1cf 1284 {
42655d16 1285 Double_t zin = pin->GetZ();
1286 Double_t zout = pout->GetZ();
1287 if (zin*zout<0) pass=kFALSE; //reject if cross the membrane
1288 if (zin < fIgnoreTPCzRangeMin || zin > fIgnoreTPCzRangeMax) pass=kFALSE;
1289 if (zout < fIgnoreTPCzRangeMin || zout > fIgnoreTPCzRangeMax) pass=kFALSE;
441ea1cf 1290 }
42655d16 1291 }
32b846cd 1292
1a80f9f6 1293 Int_t ntpccls = ( fParamType==kTPCstandalone )?
42655d16 1294 track->GetTPCNclsIter1():track->GetTPCNcls();
1295 if (fCutChi2PerClusterTPC)
1296 {
1a80f9f6 1297 Float_t tpcchi2 = (fParamType==kTPCstandalone)?
42655d16 1298 track->GetTPCchi2Iter1():track->GetTPCchi2();
1299 tpcchi2 = (ntpccls>0)?tpcchi2/ntpccls:-FLT_MAX;
1300 if (tpcchi2<fMinChi2PerClusterTPC || tpcchi2 >=fMaxChi2PerClusterTPC)
1301 pass=kFALSE;
1302 }
1303
2b1eaa10 1304 if (fCutMinimalTPCdedx)
1305 {
1306 if (track->GetTPCsignal() < fMinimalTPCdedx) pass=kFALSE;
1307 }
1308
42655d16 1309 if (fCutNClustersTPC)
1310 {
1311 if (ntpccls < fNClustersTPCMin || ntpccls > fNClustersTPCMax) pass=kFALSE;
1312 }
1313
1314 Int_t nitscls = track->GetNcls(0);
1315 if (fCutNClustersITS)
1316 {
1317 if (nitscls < fNClustersITSMin || nitscls > fNClustersITSMax) pass=kFALSE;
1318 }
32b846cd 1319
1a80f9f6 1320 //some stuff is still handled by AliESDtrackCuts class - delegate
1321 if (fAliESDtrackCuts)
1322 {
1323 if (!fAliESDtrackCuts->IsSelected(track)) pass=kFALSE;
1324 }
1325
cd62a2a8 1326 //PID part with pid QA
499fe731 1327 Double_t beta = GetBeta(track);
1328 Double_t dedx = Getdedx(track);
1329 if (fQA)
1330 {
1331 if (pass) QAbefore(0)->Fill(track->GetP(),beta);
1332 if (pass) QAbefore(1)->Fill(pin->GetP(),dedx);
1333 }
a14b8f3c 1334 if (fCutPID && (fParticleID!=AliPID::kUnknown)) //if kUnknown don't cut on PID
42655d16 1335 {
3c67c769 1336 if (!PassesESDpidCut(track)) pass=kFALSE;
1337 }
0b14d0f4 1338 if (fCutRejectElectronsWithTPCpid)
1339 {
1340 //reject electrons using standard TPC pid
3c67c769 1341 //TODO this should be rethought....
0b14d0f4 1342 Double_t pidTPC[AliPID::kSPECIES];
1343 track->GetTPCpid(pidTPC);
1344 if (pidTPC[AliPID::kElectron]<fParticleProbability) pass=kFALSE;
1345 }
499fe731 1346 if (fQA)
1347 {
1348 if (pass) QAafter(0)->Fill(track->GetP(),beta);
1349 if (pass) QAafter(1)->Fill(pin->GetP(),dedx);
1350 }
cd62a2a8 1351 //end pid part with qa
3c67c769 1352
cd62a2a8 1353 if (fQA)
1354 {
1355 Double_t pt = track->Pt();
1356 QAbefore(5)->Fill(pt,dcaxy);
1357 QAbefore(6)->Fill(pt,dcaz);
1358 if (pass) QAafter(5)->Fill(pt,dcaxy);
1359 if (pass) QAafter(6)->Fill(pt,dcaz);
dd294bb6
MK		 1360 QAbefore(17)->Fill(Float_t(track->GetKinkIndex(0)));
1361 if (pass) QAafter(17)->Fill(Float_t(track->GetKinkIndex(0)));
cd62a2a8 1362 }
32b846cd 1363
42655d16 1364 return pass;
daf66719 1365}
1366
1367//-----------------------------------------------------------------------
1368void AliFlowTrackCuts::HandleVParticle(AliVParticle* track)
1369{
1370 //handle the general case
daf66719 1371 switch (fParamType)
1372 {
daf66719 1373 default:
daf66719 1374 fTrack = track;
32b846cd 1375 break;
daf66719 1376 }
1377}
1378
1379//-----------------------------------------------------------------------
1380void AliFlowTrackCuts::HandleESDtrack(AliESDtrack* track)
1381{
1382 //handle esd track
daf66719 1383 switch (fParamType)
1384 {
12b2b8bc 1385 case kGlobal:
daf66719 1386 fTrack = track;
daf66719 1387 break;
1a80f9f6 1388 case kTPCstandalone:
2b1eaa10 1389 if (!track->FillTPCOnlyTrack(fTPCtrack))
1ff4bda1 1390 {
1391 fTrack=NULL;
1392 fMCparticle=NULL;
2281e7c5 1393 fTrackLabel=-998;
1ff4bda1 1394 return;
1395 }
1396 fTrack = &fTPCtrack;
957517fa 1397 //recalculate the label and mc particle, they may differ as TPClabel != global label
127a5825 1398 fTrackLabel = (fFakesAreOK)?TMath::Abs(fTrack->GetLabel()):fTrack->GetLabel();
1399 if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
957517fa 1400 else fMCparticle=NULL;
daf66719 1401 break;
daf66719 1402 default:
dd294bb6
MK		 1403 if (fForceTPCstandalone)
1404 {
1405 if (!track->FillTPCOnlyTrack(fTPCtrack))
1406 {
1407 fTrack=NULL;
1408 fMCparticle=NULL;
1409 fTrackLabel=-998;
1410 return;
1411 }
1412 fTrack = &fTPCtrack;
1413 //recalculate the label and mc particle, they may differ as TPClabel != global label
1414 fTrackLabel = (fFakesAreOK)?TMath::Abs(fTrack->GetLabel()):fTrack->GetLabel();
1415 if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
1416 else fMCparticle=NULL;
1417 }
1418 else
1419 fTrack = track;
32b846cd 1420 break;
daf66719 1421 }
1422}
1423
a0241c3a 1424//-----------------------------------------------------------------------
1425Int_t AliFlowTrackCuts::Count(AliVEvent* event)
1426{
1427 //calculate the number of track in given event.
1428 //if argument is NULL(default) take the event attached
1429 //by SetEvent()
1430 Int_t multiplicity = 0;
1431 if (!event)
1432 {
1433 for (Int_t i=0; i<GetNumberOfInputObjects(); i++)
1434 {
1435 if (IsSelected(GetInputObject(i))) multiplicity++;
1436 }
1437 }
1438 else
1439 {
1440 for (Int_t i=0; i<event->GetNumberOfTracks(); i++)
1441 {
1442 if (IsSelected(event->GetTrack(i))) multiplicity++;
1443 }
1444 }
1445 return multiplicity;
1446}
1447
902ad6f1 1448//-----------------------------------------------------------------------
6c9a4feb 1449AliFlowTrackCuts* AliFlowTrackCuts::GetAODTrackCutsForFilterBit(UInt_t bit, TString suffix)
902ad6f1 1450{
1451 // object which in its default form only cuts on filterbit (for AOD analysis)
819dadc0 1452 // NOTE : the cut object is defined in such a way that ONLY filterbit is tested,
1453 // all other paramters are NOT checked
1454 // the exception is TPCdecx which is always cut for reasons of backward compatibility
1455 // but by setting the threshold to larger than -99999999 effectively there is no check
6c9a4feb 1456 AliFlowTrackCuts* cuts = new AliFlowTrackCuts(Form("AOD fitlerbit %i, %s", (int)bit, suffix.Data()));
902ad6f1 1457 cuts->SetMinimalTPCdedx(-999999999);
1458 cuts->SetAODfilterBit(bit);
7d7bf930 1459 cuts->SetParamType(AliFlowTrackCuts::kAODFilterBit);
902ad6f1 1460 return cuts;
1461}
1a80f9f6 1462//-----------------------------------------------------------------------
1463AliFlowTrackCuts* AliFlowTrackCuts::GetStandardVZEROOnlyTrackCuts()
54dd223b 1464{
1465 //returns the lhc10h vzero track cuts, this function
1466 //is left here for backward compatibility
1467 //if a run is recognized as 11h, the calibration method will
1468 //switch to 11h calbiration, which means that the cut
1469 //object is updated but not replaced.
1470 //calibratin is only available for PbPb runs
1471 return GetStandardVZEROOnlyTrackCuts2010();
1472}
1473//-----------------------------------------------------------------------
1474AliFlowTrackCuts* AliFlowTrackCuts::GetStandardVZEROOnlyTrackCuts2010()
1a80f9f6 1475{
c27333c2 1476 //get standard VZERO cuts
07a3fb14 1477 //DISCLAIMER: LHC10h VZERO calibration consists (by default) of two steps
1478 //1) re-weigting of signal
1479 //2) re-centering of q-vectors
1480 //step 2 is available only for n==2 and n==3, for the higher harmonics the user
1481 //is repsonsible for making sure the q-sub distributions are (sufficiently) flat
1482 //or a sensible NUA procedure is applied !
6c9a4feb 1483 AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard vzero flow cuts");
07a3fb14 1484 cuts->SetParamType(AliFlowTrackCuts::kVZERO);
1a80f9f6 1485 cuts->SetEtaRange( -10, +10 );
07a3fb14 1486 cuts->SetEtaGap(-1., 1.);
1a80f9f6 1487 cuts->SetPhiMin( 0 );
1488 cuts->SetPhiMax( TMath::TwoPi() );
86a97121 1489 // options for the reweighting
c27333c2 1490 cuts->SetVZEROgainEqualizationPerRing(kFALSE);
54dd223b 1491 cuts->SetApplyRecentering(kTRUE);
07a3fb14 1492 // to exclude a ring , do e.g.
54dd223b 1493 // cuts->SetUseVZERORing(7, kFALSE);
07a3fb14 1494 // excluding a ring will break the re-centering as re-centering relies on a
1495 // database file which tuned to receiving info from all rings
54dd223b 1496 return cuts;
1497}
1498//-----------------------------------------------------------------------
1499AliFlowTrackCuts* AliFlowTrackCuts::GetStandardVZEROOnlyTrackCuts2011()
1500{
c27333c2 1501 //get standard VZERO cuts for 2011 data
54dd223b 1502 //in this case, the vzero segments will be weighted by
1503 //VZEROEqMultiplicity,
1504 //if recentering is enableded, the sub-q vectors
1505 //will be taken from the event header, so make sure to run
1506 //the VZERO event plane selection task before this task !
07a3fb14 1507 //DISCLAIMER: recentering is only available for n==2
1508 //for the higher harmonics the user
1509 //is repsonsible for making sure the q-sub distributions are (sufficiently) flat
1510 //or a sensible NUA procedure is applied !
54dd223b 1511 //recentering replaces the already evaluated q-vectors, so
1512 //when chosen, additional settings (e.g. excluding rings)
1513 //have no effect. recentering is true by default
1514 //
1515 //NOTE user is responsible for running the vzero event plane
1516 //selection task in advance, e.g. add to your launcher macro
1517 //
1518 // gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskVZEROEPSelection.C");
1519 // AddTaskVZEROEPSelection();
1520 //
1521 AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard vzero flow cuts 2011");
c27333c2 1522 cuts->SetParamType(kVZERO);
54dd223b 1523 cuts->SetEtaRange( -10, +10 );
07a3fb14 1524 cuts->SetEtaGap(-1., 1.);
54dd223b 1525 cuts->SetPhiMin( 0 );
1526 cuts->SetPhiMax( TMath::TwoPi() );
1527 cuts->SetApplyRecentering(kTRUE);
d0ce6147 1528 cuts->SetVZEROgainEqualizationPerRing(kFALSE);
1529 return cuts;
1a80f9f6 1530}
a0241c3a 1531//-----------------------------------------------------------------------
1532AliFlowTrackCuts* AliFlowTrackCuts::GetStandardGlobalTrackCuts2010()
1533{
1534 //get standard cuts
1a80f9f6 1535 AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard Global tracks");
a0241c3a 1536 cuts->SetParamType(kGlobal);
1537 cuts->SetPtRange(0.2,5.);
1538 cuts->SetEtaRange(-0.8,0.8);
1539 cuts->SetMinNClustersTPC(70);
1540 cuts->SetMinChi2PerClusterTPC(0.1);
1541 cuts->SetMaxChi2PerClusterTPC(4.0);
1542 cuts->SetMinNClustersITS(2);
1543 cuts->SetRequireITSRefit(kTRUE);
1544 cuts->SetRequireTPCRefit(kTRUE);
1545 cuts->SetMaxDCAToVertexXY(0.3);
1546 cuts->SetMaxDCAToVertexZ(0.3);
1547 cuts->SetAcceptKinkDaughters(kFALSE);
2b1eaa10 1548 cuts->SetMinimalTPCdedx(10.);
a0241c3a 1549
1550 return cuts;
1551}
1552
1553//-----------------------------------------------------------------------
1a80f9f6 1554AliFlowTrackCuts* AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010()
a0241c3a 1555{
1556 //get standard cuts
1a80f9f6 1557 AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard TPC standalone 2010");
1558 cuts->SetParamType(kTPCstandalone);
a0241c3a 1559 cuts->SetPtRange(0.2,5.);
1560 cuts->SetEtaRange(-0.8,0.8);
1561 cuts->SetMinNClustersTPC(70);
1562 cuts->SetMinChi2PerClusterTPC(0.2);
1563 cuts->SetMaxChi2PerClusterTPC(4.0);
1564 cuts->SetMaxDCAToVertexXY(3.0);
1565 cuts->SetMaxDCAToVertexZ(3.0);
1566 cuts->SetDCAToVertex2D(kTRUE);
1567 cuts->SetAcceptKinkDaughters(kFALSE);
2b1eaa10 1568 cuts->SetMinimalTPCdedx(10.);
a0241c3a 1569
1570 return cuts;
1571}
1572
daf66719 1573//-----------------------------------------------------------------------
1a80f9f6 1574AliFlowTrackCuts* AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts()
daf66719 1575{
1576 //get standard cuts
1a80f9f6 1577 AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard TPC standalone");
1578 cuts->SetParamType(kTPCstandalone);
a0241c3a 1579 cuts->SetPtRange(0.2,5.);
1580 cuts->SetEtaRange(-0.8,0.8);
1581 cuts->SetMinNClustersTPC(70);
1582 cuts->SetMinChi2PerClusterTPC(0.2);
1583 cuts->SetMaxChi2PerClusterTPC(4.0);
1584 cuts->SetMaxDCAToVertexXY(3.0);
1585 cuts->SetMaxDCAToVertexZ(3.0);
1586 cuts->SetDCAToVertex2D(kTRUE);
1587 cuts->SetAcceptKinkDaughters(kFALSE);
2b1eaa10 1588 cuts->SetMinimalTPCdedx(10.);
a0241c3a 1589
daf66719 1590 return cuts;
1591}
1592
1593//-----------------------------------------------------------------------
1594AliFlowTrackCuts* AliFlowTrackCuts::GetStandardITSTPCTrackCuts2009(Bool_t selPrimaries)
1595{
1596 //get standard cuts
441ea1cf 1597 AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard global track cuts 2009");
daf66719 1598 delete cuts->fAliESDtrackCuts;
1599 cuts->fAliESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selPrimaries);
12b2b8bc 1600 cuts->SetParamType(kGlobal);
daf66719 1601 return cuts;
1602}
1603
2e5052c5 1604//-----------------------------------------------------------------------------
84714904 1605AliFlowTrackCuts* AliFlowTrackCuts::GetStandardMuonTrackCuts(Bool_t isMC, Int_t passN)
2e5052c5 1606{
1607// XZhang 20120604
1608 AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard muon track cuts");
1609 cuts->SetParamType(kMUON);
1610 cuts->SetStandardMuonTrackCuts();
1611 cuts->SetIsMuonMC(isMC);
84714904 1612 cuts->SetMuonPassNumber(passN);
2e5052c5 1613 return cuts;
1614}
1615
dd294bb6
MK		 1616//-----------------------------------------------------------------------
1617//AliFlowTrack* AliFlowTrackCuts::FillFlowTrackV0(TObjArray* trackCollection, Int_t trackIndex) const
1618//{
1619// //fill flow track from a reconstructed V0 (topological)
1620// AliFlowTrack* flowtrack = static_cast<AliFlowTrack*>(trackCollection->At(trackIndex));
1621// if (flowtrack)
1622// {
1623// flowtrack->Clear();
1624// }
1625// else
1626// {
1627// flowtrack = new AliFlowCandidateTrack();
1628// trackCollection->AddAtAndExpand(flowtrack,trackIndex);
1629// }
1630//
1631// TParticle *tmpTParticle=NULL;
1632// AliMCParticle* tmpAliMCParticle=NULL;
1633// AliExternalTrackParam* externalParams=NULL;
1634// AliESDtrack* esdtrack=NULL;
1635// switch(fParamMix)
1636// {
1637// case kPure:
1638// flowtrack->Set(fTrack);
1639// break;
1640// case kTrackWithMCkine:
1641// flowtrack->Set(fMCparticle);
1642// break;
1643// case kTrackWithMCPID:
1644// flowtrack->Set(fTrack);
1645// //flowtrack->setPID(...) from mc, when implemented
1646// break;
1647// case kTrackWithMCpt:
1648// if (!fMCparticle) return NULL;
1649// flowtrack->Set(fTrack);
1650// flowtrack->SetPt(fMCparticle->Pt());
1651// break;
1652// case kTrackWithPtFromFirstMother:
1653// if (!fMCparticle) return NULL;
1654// flowtrack->Set(fTrack);
1655// tmpTParticle = fMCparticle->Particle();
1656// tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
1657// flowtrack->SetPt(tmpAliMCParticle->Pt());
1658// break;
1659// case kTrackWithTPCInnerParams:
1660// esdtrack = dynamic_cast<AliESDtrack*>(fTrack);
1661// if (!esdtrack) return NULL;
1662// externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam());
1663// if (!externalParams) return NULL;
1664// flowtrack->Set(externalParams);
1665// break;
1666// default:
1667// flowtrack->Set(fTrack);
1668// break;
1669// }
1670// if (fParamType==kMC)
1671// {
1672// flowtrack->SetSource(AliFlowTrack::kFromMC);
1673// flowtrack->SetID(fTrackLabel);
1674// }
1675// else if (dynamic_cast<AliAODTrack*>(fTrack))
1676// {
1677// if (fParamType==kMUON) // XZhang 20120604
1678// flowtrack->SetSource(AliFlowTrack::kFromMUON); // XZhang 20120604
1679// else // XZhang 20120604
1680// flowtrack->SetSource(AliFlowTrack::kFromAOD); // XZhang 20120604
1681// flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
1682// }
1683// else if (dynamic_cast<AliMCParticle*>(fTrack))
1684// {
1685// flowtrack->SetSource(AliFlowTrack::kFromMC);
1686// flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
1687// }
1688//
1689// if (fV0)
1690// {
1691// //add daughter indices
1692// }
1693//
1694// return flowtrack;
1695//}
1696
1697//-----------------------------------------------------------------------
1698AliFlowTrack* AliFlowTrackCuts::FillFlowTrackKink(TObjArray* trackCollection, Int_t trackIndex) const
1699{
1700 //fill flow track from AliVParticle (ESD,AOD,MC)
1701 AliFlowTrack* flowtrack = static_cast<AliFlowTrack*>(trackCollection->At(trackIndex));
1702 if (flowtrack)
1703 {
1704 flowtrack->Clear();
1705 }
1706 else
1707 {
1708 flowtrack = new AliFlowCandidateTrack();
1709 trackCollection->AddAtAndExpand(flowtrack,trackIndex);
1710 }
1711
1712 TParticle *tmpTParticle=NULL;
1713 AliMCParticle* tmpAliMCParticle=NULL;
1714 AliExternalTrackParam* externalParams=NULL;
1715 AliESDtrack* esdtrack=NULL;
1716 switch(fParamMix)
1717 {
1718 case kPure:
1719 flowtrack->Set(fTrack);
1720 break;
1721 case kTrackWithMCkine:
1722 flowtrack->Set(fMCparticle);
1723 break;
1724 case kTrackWithMCPID:
1725 flowtrack->Set(fTrack);
1726 //flowtrack->setPID(...) from mc, when implemented
1727 break;
1728 case kTrackWithMCpt:
1729 if (!fMCparticle) return NULL;
1730 flowtrack->Set(fTrack);
1731 flowtrack->SetPt(fMCparticle->Pt());
1732 break;
1733 case kTrackWithPtFromFirstMother:
1734 if (!fMCparticle) return NULL;
1735 flowtrack->Set(fTrack);
1736 tmpTParticle = fMCparticle->Particle();
1737 tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
1738 flowtrack->SetPt(tmpAliMCParticle->Pt());
1739 break;
1740 case kTrackWithTPCInnerParams:
1741 esdtrack = dynamic_cast<AliESDtrack*>(fTrack);
1742 if (!esdtrack) return NULL;
1743 externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam());
1744 if (!externalParams) return NULL;
1745 flowtrack->Set(externalParams);
1746 break;
1747 default:
1748 flowtrack->Set(fTrack);
1749 break;
1750 }
1751 if (fParamType==kMC)
1752 {
1753 flowtrack->SetSource(AliFlowTrack::kFromMC);
1754 flowtrack->SetID(fTrackLabel);
1755 }
1756 else if (dynamic_cast<AliESDtrack*>(fTrack))
1757 {
1758 flowtrack->SetSource(AliFlowTrack::kFromESD);
1759 flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
1760 }
1761 else if (dynamic_cast<AliESDMuonTrack*>(fTrack)) // XZhang 20120604
1762 { // XZhang 20120604
1763 flowtrack->SetSource(AliFlowTrack::kFromMUON); // XZhang 20120604
1764 flowtrack->SetID((Int_t)static_cast<AliESDMuonTrack*>(fTrack)->GetUniqueID()); // XZhang 20120604
1765 } // XZhang 20120604
1766 else if (dynamic_cast<AliAODTrack*>(fTrack))
1767 {
1768 if (fParamType==kMUON) // XZhang 20120604
1769 flowtrack->SetSource(AliFlowTrack::kFromMUON); // XZhang 20120604
1770 else // XZhang 20120604
1771 flowtrack->SetSource(AliFlowTrack::kFromAOD); // XZhang 20120604
1772 flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
1773 }
1774 else if (dynamic_cast<AliMCParticle*>(fTrack))
1775 {
1776 flowtrack->SetSource(AliFlowTrack::kFromMC);
1777 flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
1778 }
1779
1780 if (fKink)
1781 {
1782 Int_t indexMother = fKink->GetIndex(0);
1783 Int_t indexDaughter = fKink->GetIndex(1);
1784 flowtrack->SetID(indexMother);
1785 flowtrack->AddDaughter(indexDaughter);
1786 flowtrack->SetMass(1.);
1787 flowtrack->SetSource(AliFlowTrack::kFromKink);
1788 }
1789
1790 flowtrack->SetMass(fTrackMass);
1791
1792 return flowtrack;
1793}
1794
1795//-----------------------------------------------------------------------
1796AliFlowTrack* AliFlowTrackCuts::FillFlowTrackGeneric(TObjArray* trackCollection, Int_t trackIndex) const
1797{
1798 //fill a flow track from tracklet,vzero,pmd,...
1799 AliFlowTrack* flowtrack = static_cast<AliFlowTrack*>(trackCollection->At(trackIndex));
1800 if (flowtrack)
1801 {
1802 flowtrack->Clear();
1803 }
1804 else
1805 {
1806 flowtrack = new AliFlowTrack();
1807 trackCollection->AddAtAndExpand(flowtrack,trackIndex);
1808 }
1809
1810 if (FillFlowTrackGeneric(flowtrack)) return flowtrack;
1811 else
1812 {
1813 trackCollection->RemoveAt(trackIndex);
1814 delete flowtrack;
1815 return NULL;
1816 }
1817}
1818
7d27a354 1819//-----------------------------------------------------------------------
1820Bool_t AliFlowTrackCuts::FillFlowTrackGeneric(AliFlowTrack* flowtrack) const
1821{
1822 //fill a flow track from tracklet,vzero,pmd,...
1823 TParticle *tmpTParticle=NULL;
1824 AliMCParticle* tmpAliMCParticle=NULL;
1825 switch (fParamMix)
1826 {
1827 case kPure:
1828 flowtrack->SetPhi(fTrackPhi);
1829 flowtrack->SetEta(fTrackEta);
2281e7c5 1830 flowtrack->SetWeight(fTrackWeight);
dd294bb6
MK		 1831 flowtrack->SetPt(fTrackPt);
1832 flowtrack->SetMass(fTrackMass);
7d27a354 1833 break;
1834 case kTrackWithMCkine:
1835 if (!fMCparticle) return kFALSE;
1836 flowtrack->SetPhi( fMCparticle->Phi() );
1837 flowtrack->SetEta( fMCparticle->Eta() );
1838 flowtrack->SetPt( fMCparticle->Pt() );
dd294bb6 1839 flowtrack->SetMass(fTrackMass);
7d27a354 1840 break;
1841 case kTrackWithMCpt:
1842 if (!fMCparticle) return kFALSE;
1843 flowtrack->SetPhi(fTrackPhi);
1844 flowtrack->SetEta(fTrackEta);
2281e7c5 1845 flowtrack->SetWeight(fTrackWeight);
7d27a354 1846 flowtrack->SetPt(fMCparticle->Pt());
dd294bb6 1847 flowtrack->SetMass(fTrackMass);
7d27a354 1848 break;
1849 case kTrackWithPtFromFirstMother:
1850 if (!fMCparticle) return kFALSE;
1851 flowtrack->SetPhi(fTrackPhi);
1852 flowtrack->SetEta(fTrackEta);
2281e7c5 1853 flowtrack->SetWeight(fTrackWeight);
7d27a354 1854 tmpTParticle = fMCparticle->Particle();
1855 tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
1856 flowtrack->SetPt(tmpAliMCParticle->Pt());
dd294bb6 1857 flowtrack->SetMass(fTrackMass);
7d27a354 1858 break;
1859 default:
1860 flowtrack->SetPhi(fTrackPhi);
1861 flowtrack->SetEta(fTrackEta);
2281e7c5 1862 flowtrack->SetWeight(fTrackWeight);
dd294bb6
MK		 1863 flowtrack->SetPt(fTrackPt);
1864 flowtrack->SetMass(fTrackMass);
7d27a354 1865 break;
1866 }
1867 flowtrack->SetSource(AliFlowTrack::kFromTracklet);
1868 return kTRUE;
1869}
1870
dd294bb6
MK		 1871//-----------------------------------------------------------------------
1872AliFlowTrack* AliFlowTrackCuts::FillFlowTrackVParticle(TObjArray* trackCollection, Int_t trackIndex) const
1873{
1874 //fill flow track from AliVParticle (ESD,AOD,MC)
1875
1876 AliFlowTrack* flowtrack = static_cast<AliFlowTrack*>(trackCollection->At(trackIndex));
1877 if (flowtrack)
1878 {
1879 flowtrack->Clear();
1880 }
1881 else
1882 {
1883 flowtrack = new AliFlowTrack();
1884 trackCollection->AddAtAndExpand(flowtrack,trackIndex);
1885 }
1886
1887 if (FillFlowTrackVParticle(flowtrack)) return flowtrack;
1888 else
1889 {
1890 trackCollection->RemoveAt(trackIndex);
1891 delete flowtrack;
1892 return NULL;
1893 }
1894}
1895
7d27a354 1896//-----------------------------------------------------------------------
1897Bool_t AliFlowTrackCuts::FillFlowTrackVParticle(AliFlowTrack* flowtrack) const
1898{
1899 //fill flow track from AliVParticle (ESD,AOD,MC)
1900 if (!fTrack) return kFALSE;
1901 TParticle *tmpTParticle=NULL;
1902 AliMCParticle* tmpAliMCParticle=NULL;
1903 AliExternalTrackParam* externalParams=NULL;
1904 AliESDtrack* esdtrack=NULL;
1905 switch(fParamMix)
1906 {
1907 case kPure:
1908 flowtrack->Set(fTrack);
1909 break;
1910 case kTrackWithMCkine:
1911 flowtrack->Set(fMCparticle);
1912 break;
1913 case kTrackWithMCPID:
1914 flowtrack->Set(fTrack);
1915 //flowtrack->setPID(...) from mc, when implemented
1916 break;
1917 case kTrackWithMCpt:
1918 if (!fMCparticle) return kFALSE;
1919 flowtrack->Set(fTrack);
1920 flowtrack->SetPt(fMCparticle->Pt());
1921 break;
1922 case kTrackWithPtFromFirstMother:
1923 if (!fMCparticle) return kFALSE;
1924 flowtrack->Set(fTrack);
1925 tmpTParticle = fMCparticle->Particle();
1926 tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
1927 flowtrack->SetPt(tmpAliMCParticle->Pt());
1928 break;
1929 case kTrackWithTPCInnerParams:
1930 esdtrack = dynamic_cast<AliESDtrack*>(fTrack);
1931 if (!esdtrack) return kFALSE;
1932 externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam());
1933 if (!externalParams) return kFALSE;
1934 flowtrack->Set(externalParams);
1935 break;
1936 default:
1937 flowtrack->Set(fTrack);
1938 break;
1939 }
499fe731 1940 if (fParamType==kMC)
1941 {
1942 flowtrack->SetSource(AliFlowTrack::kFromMC);
2281e7c5 1943 flowtrack->SetID(fTrackLabel);
499fe731 1944 }
1945 else if (dynamic_cast<AliESDtrack*>(fTrack))
1946 {
1947 flowtrack->SetSource(AliFlowTrack::kFromESD);
1948 flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
1949 }
2e5052c5 1950 else if (dynamic_cast<AliESDMuonTrack*>(fTrack)) // XZhang 20120604
1951 { // XZhang 20120604
1952 flowtrack->SetSource(AliFlowTrack::kFromMUON); // XZhang 20120604
1953 flowtrack->SetID((Int_t)static_cast<AliESDMuonTrack*>(fTrack)->GetUniqueID()); // XZhang 20120604
1954 } // XZhang 20120604
1955 else if (dynamic_cast<AliAODTrack*>(fTrack))
1956 {
1957 if (fParamType==kMUON) // XZhang 20120604
1958 flowtrack->SetSource(AliFlowTrack::kFromMUON); // XZhang 20120604
1959 else // XZhang 20120604
1960 flowtrack->SetSource(AliFlowTrack::kFromAOD); // XZhang 20120604
499fe731 1961 flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
1962 }
1963 else if (dynamic_cast<AliMCParticle*>(fTrack))
1964 {
1965 flowtrack->SetSource(AliFlowTrack::kFromMC);
1966 flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
1967 }
dd294bb6 1968 flowtrack->SetMass(fTrackMass);
7d27a354 1969 return kTRUE;
1970}
1971
dd294bb6
MK		 1972//-----------------------------------------------------------------------
1973AliFlowTrack* AliFlowTrackCuts::FillFlowTrack(TObjArray* trackCollection, Int_t trackIndex) const
1974{
1975 //fill a flow track constructed from whatever we applied cuts on
1976 //return true on success
1977 switch (fParamType)
1978 {
1979 case kSPDtracklet:
1980 return FillFlowTrackGeneric(trackCollection, trackIndex);
1981 case kPMD:
1982 return FillFlowTrackGeneric(trackCollection, trackIndex);
1983 case kVZERO:
1984 return FillFlowTrackGeneric(trackCollection, trackIndex);
1985 case kKink:
1986 return FillFlowTrackKink(trackCollection, trackIndex);
1987 //case kV0:
1988 // return FillFlowTrackV0(trackCollection, trackIndex);
1989 default:
1990 return FillFlowTrackVParticle(trackCollection, trackIndex);
1991 }
1992}
1993
7d27a354 1994//-----------------------------------------------------------------------
1995Bool_t AliFlowTrackCuts::FillFlowTrack(AliFlowTrack* track) const
1996{
1997 //fill a flow track constructed from whatever we applied cuts on
1998 //return true on success
1999 switch (fParamType)
2000 {
2001 case kSPDtracklet:
2002 return FillFlowTrackGeneric(track);
2003 case kPMD:
2004 return FillFlowTrackGeneric(track);
c27333c2 2005 case kVZERO:
7d27a354 2006 return FillFlowTrackGeneric(track);
2007 default:
2008 return FillFlowTrackVParticle(track);
2009 }
2010}
2011
cac040c5
MK		 2012////-----------------------------------------------------------------------
2013//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackSPDtracklet() const
2014//{
2015// //make a flow track from tracklet
2016// AliFlowTrack* flowtrack=NULL;
2017// TParticle *tmpTParticle=NULL;
2018// AliMCParticle* tmpAliMCParticle=NULL;
2019// switch (fParamMix)
2020// {
2021// case kPure:
2022// flowtrack = new AliFlowTrack();
2023// flowtrack->SetPhi(fTrackPhi);
2024// flowtrack->SetEta(fTrackEta);
2025// flowtrack->SetWeight(fTrackWeight);
2026// break;
2027// case kTrackWithMCkine:
2028// if (!fMCparticle) return NULL;
2029// flowtrack = new AliFlowTrack();
2030// flowtrack->SetPhi( fMCparticle->Phi() );
2031// flowtrack->SetEta( fMCparticle->Eta() );
2032// flowtrack->SetPt( fMCparticle->Pt() );
2033// break;
2034// case kTrackWithMCpt:
2035// if (!fMCparticle) return NULL;
2036// flowtrack = new AliFlowTrack();
2037// flowtrack->SetPhi(fTrackPhi);
2038// flowtrack->SetEta(fTrackEta);
2039// flowtrack->SetWeight(fTrackWeight);
2040// flowtrack->SetPt(fMCparticle->Pt());
2041// break;
2042// case kTrackWithPtFromFirstMother:
2043// if (!fMCparticle) return NULL;
2044// flowtrack = new AliFlowTrack();
2045// flowtrack->SetPhi(fTrackPhi);
2046// flowtrack->SetEta(fTrackEta);
2047// flowtrack->SetWeight(fTrackWeight);
2048// tmpTParticle = fMCparticle->Particle();
2049// tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
2050// flowtrack->SetPt(tmpAliMCParticle->Pt());
2051// break;
2052// default:
2053// flowtrack = new AliFlowTrack();
2054// flowtrack->SetPhi(fTrackPhi);
2055// flowtrack->SetEta(fTrackEta);
2056// flowtrack->SetWeight(fTrackWeight);
2057// break;
2058// }
2059// flowtrack->SetSource(AliFlowTrack::kFromTracklet);
2060// return flowtrack;
2061//}
2062//
2063////-----------------------------------------------------------------------
2064//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackVParticle() const
2065//{
2066// //make flow track from AliVParticle (ESD,AOD,MC)
2067// if (!fTrack) return NULL;
2068// AliFlowTrack* flowtrack=NULL;
2069// TParticle *tmpTParticle=NULL;
2070// AliMCParticle* tmpAliMCParticle=NULL;
2071// AliExternalTrackParam* externalParams=NULL;
2072// AliESDtrack* esdtrack=NULL;
2073// switch(fParamMix)
2074// {
2075// case kPure:
2076// flowtrack = new AliFlowTrack(fTrack);
2077// break;
2078// case kTrackWithMCkine:
2079// flowtrack = new AliFlowTrack(fMCparticle);
2080// break;
2081// case kTrackWithMCPID:
2082// flowtrack = new AliFlowTrack(fTrack);
2083// //flowtrack->setPID(...) from mc, when implemented
2084// break;
2085// case kTrackWithMCpt:
2086// if (!fMCparticle) return NULL;
2087// flowtrack = new AliFlowTrack(fTrack);
2088// flowtrack->SetPt(fMCparticle->Pt());
2089// break;
2090// case kTrackWithPtFromFirstMother:
2091// if (!fMCparticle) return NULL;
2092// flowtrack = new AliFlowTrack(fTrack);
2093// tmpTParticle = fMCparticle->Particle();
2094// tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
2095// flowtrack->SetPt(tmpAliMCParticle->Pt());
2096// break;
2097// case kTrackWithTPCInnerParams:
2098// esdtrack = dynamic_cast<AliESDtrack*>(fTrack);
2099// if (!esdtrack) return NULL;
2100// externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam());
2101// if (!externalParams) return NULL;
2102// flowtrack = new AliFlowTrack(externalParams);
2103// break;
2104// default:
2105// flowtrack = new AliFlowTrack(fTrack);
2106// break;
2107// }
2108// if (fParamType==kMC)
2109// {
2110// flowtrack->SetSource(AliFlowTrack::kFromMC);
2111// flowtrack->SetID(fTrackLabel);
2112// }
2113// else if (dynamic_cast<AliESDtrack*>(fTrack))
2114// {
2115// flowtrack->SetSource(AliFlowTrack::kFromESD);
2116// flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
2117// }
2118// else if (dynamic_cast<AliAODTrack*>(fTrack))
2119// {
2120// flowtrack->SetSource(AliFlowTrack::kFromAOD);
2121// flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
2122// }
2123// else if (dynamic_cast<AliMCParticle*>(fTrack))
2124// {
2125// flowtrack->SetSource(AliFlowTrack::kFromMC);
2126// flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
2127// }
2128// return flowtrack;
2129//}
2130//
2131////-----------------------------------------------------------------------
2132//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackPMDtrack() const
2133//{
2134// //make a flow track from PMD track
2135// AliFlowTrack* flowtrack=NULL;
2136// TParticle *tmpTParticle=NULL;
2137// AliMCParticle* tmpAliMCParticle=NULL;
2138// switch (fParamMix)
2139// {
2140// case kPure:
2141// flowtrack = new AliFlowTrack();
2142// flowtrack->SetPhi(fTrackPhi);
2143// flowtrack->SetEta(fTrackEta);
2144// flowtrack->SetWeight(fTrackWeight);
2145// break;
2146// case kTrackWithMCkine:
2147// if (!fMCparticle) return NULL;
2148// flowtrack = new AliFlowTrack();
2149// flowtrack->SetPhi( fMCparticle->Phi() );
2150// flowtrack->SetEta( fMCparticle->Eta() );
2151// flowtrack->SetWeight(fTrackWeight);
2152// flowtrack->SetPt( fMCparticle->Pt() );
2153// break;
2154// case kTrackWithMCpt:
2155// if (!fMCparticle) return NULL;
2156// flowtrack = new AliFlowTrack();
2157// flowtrack->SetPhi(fTrackPhi);
2158// flowtrack->SetEta(fTrackEta);
2159// flowtrack->SetWeight(fTrackWeight);
2160// flowtrack->SetPt(fMCparticle->Pt());
2161// break;
2162// case kTrackWithPtFromFirstMother:
2163// if (!fMCparticle) return NULL;
2164// flowtrack = new AliFlowTrack();
2165// flowtrack->SetPhi(fTrackPhi);
2166// flowtrack->SetEta(fTrackEta);
2167// flowtrack->SetWeight(fTrackWeight);
2168// tmpTParticle = fMCparticle->Particle();
2169// tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
2170// flowtrack->SetPt(tmpAliMCParticle->Pt());
2171// break;
2172// default:
2173// flowtrack = new AliFlowTrack();
2174// flowtrack->SetPhi(fTrackPhi);
2175// flowtrack->SetEta(fTrackEta);
2176// flowtrack->SetWeight(fTrackWeight);
2177// break;
2178// }
2179//
2180// flowtrack->SetSource(AliFlowTrack::kFromPMD);
2181// return flowtrack;
2182//}
2183//
2184////-----------------------------------------------------------------------
2185//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackVZERO() const
2186//{
2187// //make a flow track from VZERO
2188// AliFlowTrack* flowtrack=NULL;
2189// TParticle *tmpTParticle=NULL;
2190// AliMCParticle* tmpAliMCParticle=NULL;
2191// switch (fParamMix)
2192// {
2193// case kPure:
2194// flowtrack = new AliFlowTrack();
2195// flowtrack->SetPhi(fTrackPhi);
2196// flowtrack->SetEta(fTrackEta);
2197// flowtrack->SetWeight(fTrackWeight);
2198// break;
2199// case kTrackWithMCkine:
2200// if (!fMCparticle) return NULL;
2201// flowtrack = new AliFlowTrack();
2202// flowtrack->SetPhi( fMCparticle->Phi() );
2203// flowtrack->SetEta( fMCparticle->Eta() );
2204// flowtrack->SetWeight(fTrackWeight);
2205// flowtrack->SetPt( fMCparticle->Pt() );
2206// break;
2207// case kTrackWithMCpt:
2208// if (!fMCparticle) return NULL;
2209// flowtrack = new AliFlowTrack();
2210// flowtrack->SetPhi(fTrackPhi);
2211// flowtrack->SetEta(fTrackEta);
2212// flowtrack->SetWeight(fTrackWeight);
2213// flowtrack->SetPt(fMCparticle->Pt());
2214// break;
2215// case kTrackWithPtFromFirstMother:
2216// if (!fMCparticle) return NULL;
2217// flowtrack = new AliFlowTrack();
2218// flowtrack->SetPhi(fTrackPhi);
2219// flowtrack->SetEta(fTrackEta);
2220// flowtrack->SetWeight(fTrackWeight);
2221// tmpTParticle = fMCparticle->Particle();
2222// tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
2223// flowtrack->SetPt(tmpAliMCParticle->Pt());
2224// break;
2225// default:
2226// flowtrack = new AliFlowTrack();
2227// flowtrack->SetPhi(fTrackPhi);
2228// flowtrack->SetEta(fTrackEta);
2229// flowtrack->SetWeight(fTrackWeight);
2230// break;
2231// }
2232//
2233// flowtrack->SetSource(AliFlowTrack::kFromVZERO);
2234// return flowtrack;
2235//}
2236//
2237////-----------------------------------------------------------------------
2238//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrack() const
2239//{
2240// //get a flow track constructed from whatever we applied cuts on
2241// //caller is resposible for deletion
2242// //if construction fails return NULL
2243// //TODO: for tracklets, PMD and VZERO we probably need just one method,
2244// //something like MakeFlowTrackGeneric(), wait with this until
2245// //requirements quirks are known.
2246// switch (fParamType)
2247// {
2248// case kSPDtracklet:
2249// return MakeFlowTrackSPDtracklet();
2250// case kPMD:
2251// return MakeFlowTrackPMDtrack();
2252// case kVZERO:
2253// return MakeFlowTrackVZERO();
2254// default:
2255// return MakeFlowTrackVParticle();
2256// }
2257//}
dd294bb6 2258
127a5825 2259//-----------------------------------------------------------------------
2260Bool_t AliFlowTrackCuts::IsPhysicalPrimary() const
2261{
2262 //check if current particle is a physical primary
9a0783cc 2263 if (!fMCevent) return kFALSE;
2264 if (fTrackLabel<0) return kFALSE;
441ea1cf 2265 return IsPhysicalPrimary(fMCevent, fTrackLabel, fRequireTransportBitForPrimaries);
9a0783cc 2266}
2267
2268//-----------------------------------------------------------------------
441ea1cf 2269Bool_t AliFlowTrackCuts::IsPhysicalPrimary(AliMCEvent* mcEvent, Int_t label, Bool_t requiretransported)
9a0783cc 2270{
2271 //check if current particle is a physical primary
2272 Bool_t physprim=mcEvent->IsPhysicalPrimary(label);
9a0783cc 2273 AliMCParticle* track = static_cast<AliMCParticle*>(mcEvent->GetTrack(label));
2274 if (!track) return kFALSE;
2275 TParticle* particle = track->Particle();
2276 Bool_t transported = particle->TestBit(kTransportBit);
441ea1cf 2277 //printf("label: %i prim: %s, transp: %s, pass: %s\n",label, (physprim)?"YES":"NO ",(transported)?"YES":"NO ",
2278 //(physprim && (transported || !requiretransported))?"YES":"NO" );
2279 return (physprim && (transported || !requiretransported));
127a5825 2280}
12b2b8bc 2281
924b02b0 2282//-----------------------------------------------------------------------
2283void AliFlowTrackCuts::DefineHistograms()
2284{
2a745a5f 2285 //define qa histograms
1a80f9f6 2286 if (fQA) return;
2287
2281e7c5 2288 const Int_t kNbinsP=200;
499fe731 2289 Double_t binsP[kNbinsP+1];
2290 binsP[0]=0.0;
6a043318 2291 for(int i=1; i<kNbinsP+1; i++)
1a80f9f6 2292 {
2281e7c5 2293 //if(binsP[i-1]+0.05<1.01)
2294 // binsP[i]=binsP[i-1]+0.05;
2295 //else
2296 binsP[i]=binsP[i-1]+0.05;
1a80f9f6 2297 }
2298
cd62a2a8 2299 const Int_t nBinsDCA=1000;
2300 Double_t binsDCA[nBinsDCA+1];
b9cf8f8e 2301 for(int i=0; i<nBinsDCA+1; i++) {binsDCA[i]=0.01*i-5.;}
cd62a2a8 2302 //for(int i=1; i<41; i++) {binsDCA[i+100]=0.1*i+1.0;}
2303
499fe731 2304 Bool_t adddirstatus = TH1::AddDirectoryStatus();
2305 TH1::AddDirectory(kFALSE);
a14b8f3c 2306 fQA=new TList(); fQA->SetOwner();
499fe731 2307 fQA->SetName(Form("%s QA",GetName()));
a14b8f3c 2308 TList* before = new TList(); before->SetOwner();
499fe731 2309 before->SetName("before");
a14b8f3c 2310 TList* after = new TList(); after->SetOwner();
499fe731 2311 after->SetName("after");
2312 fQA->Add(before);
2313 fQA->Add(after);
f21bdf48 2314 before->Add(new TH2F("TOFbeta",";p [GeV/c];#beta",kNbinsP,binsP,1000,0.4,1.1)); //0
2315 after->Add(new TH2F("TOFbeta",";p [GeV/c];#beta",kNbinsP,binsP,1000,0.4,1.1)); //0
2316 before->Add(new TH2F("TPCdedx",";p [GeV/c];dEdx",kNbinsP,binsP,500,0,500)); //1
2317 after->Add(new TH2F("TPCdedx",";p [GeV/c];dEdx",kNbinsP,binsP,500,0,500)); //1
2318 before->Add(new TH2F("MC pid",";p[GeV/c];species",kNbinsP,binsP,10,-5, 5)); //2
2319 after->Add(new TH2F("MC pid",";p[GeV/c];species",kNbinsP,binsP,10,-5, 5)); //2
483a17da 2320 //primary
2321 TH2F* hb = new TH2F("MC primary",";p[GeV/c];primary",kNbinsP,binsP,2,-1,1);
2322 TH2F* ha = new TH2F("MC primary",";p[GeV/c];primary",kNbinsP,binsP,2,-1,1);
2323 TAxis* axis = NULL;
2324 axis = hb->GetYaxis();
2325 axis->SetBinLabel(1,"secondary");
2326 axis->SetBinLabel(2,"primary");
2327 axis = ha->GetYaxis();
2328 axis->SetBinLabel(1,"secondary");
2329 axis->SetBinLabel(2,"primary");
2330 before->Add(hb); //3
2331 after->Add(ha); //3
875ee12a 2332 //production process
483a17da 2333 hb = new TH2F("MC production process",";p[GeV/c];",kNbinsP,binsP,kMaxMCProcess,
875ee12a 2334 -0.5, kMaxMCProcess-0.5);
483a17da 2335 ha = new TH2F("MC production process",";p[GeV/c];",kNbinsP,binsP,kMaxMCProcess,
875ee12a 2336 -0.5, kMaxMCProcess-0.5);
483a17da 2337 axis = hb->GetYaxis();
875ee12a 2338 for (Int_t i=0; i<kMaxMCProcess; i++)
2339 {
2340 axis->SetBinLabel(i+1,TMCProcessName[i]);
2341 }
644f1368 2342 axis = ha->GetYaxis();
875ee12a 2343 for (Int_t i=0; i<kMaxMCProcess; i++)
2344 {
2345 axis->SetBinLabel(i+1,TMCProcessName[i]);
2346 }
2347 before->Add(hb); //4
2348 after->Add(ha); //4
cd62a2a8 2349 //DCA
2350 before->Add(new TH2F("DCAxy",";p_{t}[GeV/c];DCAxy[cm]", 100, 0., 10., nBinsDCA, binsDCA));//5
2351 after->Add(new TH2F("DCAxy",";p_{t}[GeV/c];DCAxy[cm]", 100, 0., 10., nBinsDCA, binsDCA));//5
2352 before->Add(new TH2F("DCAz",";p_{t}[GeV/c];DCAz[cm]", 100, 0., 10., nBinsDCA, binsDCA));//6
2353 after->Add(new TH2F("DCAz",";p_{t}[GeV/c];DCAz[cm]", 100, 0., 10., nBinsDCA, binsDCA));//6
8eca5d19 2354 //first mother
2281e7c5 2355 hb = new TH2F("MC first mother",";p[GeV/c];",kNbinsP,binsP,44,1.,45.);
2356 ha = new TH2F("MC first mother",";p[GeV/c];",kNbinsP,binsP,44,1.,45.);
2357 hb->GetYaxis()->SetBinLabel(1, "#gamma");
2358 ha->GetYaxis()->SetBinLabel(1, "#gamma");
2359 hb->GetYaxis()->SetBinLabel(2, "e^{+}");
2360 ha->GetYaxis()->SetBinLabel(2, "e^{+}");
2361 hb->GetYaxis()->SetBinLabel(3, "e^{-}");
2362 ha->GetYaxis()->SetBinLabel(3, "e^{-}");
2363 hb->GetYaxis()->SetBinLabel(4, "#nu");
2364 ha->GetYaxis()->SetBinLabel(4, "#nu");
2365 hb->GetYaxis()->SetBinLabel(5, "#mu^{+}");
2366 ha->GetYaxis()->SetBinLabel(5, "#mu^{+}");
2367 hb->GetYaxis()->SetBinLabel(6, "#mu^{-}");
2368 ha->GetYaxis()->SetBinLabel(6, "#mu^{-}");
2369 hb->GetYaxis()->SetBinLabel(7, "#pi^{0}");
2370 ha->GetYaxis()->SetBinLabel(7, "#pi^{0}");
2371 hb->GetYaxis()->SetBinLabel(8, "#pi^{+}");
2372 ha->GetYaxis()->SetBinLabel(8, "#pi^{+}");
2373 hb->GetYaxis()->SetBinLabel(9, "#pi^{-}");
2374 ha->GetYaxis()->SetBinLabel(9, "#pi^{-}");
2375 hb->GetYaxis()->SetBinLabel(10, "K^{0}_{L}");
2376 ha->GetYaxis()->SetBinLabel(10, "K^{0}_{L}");
2377 hb->GetYaxis()->SetBinLabel(11, "K^{+}");
2378 ha->GetYaxis()->SetBinLabel(11, "K^{+}");
2379 hb->GetYaxis()->SetBinLabel(12, "K^{-}");
2380 ha->GetYaxis()->SetBinLabel(12, "K^{-}");
2381 hb->GetYaxis()->SetBinLabel( 13, "n");
2382 ha->GetYaxis()->SetBinLabel( 13, "n");
2383 hb->GetYaxis()->SetBinLabel( 14, "p");
2384 ha->GetYaxis()->SetBinLabel( 14, "p");
2385 hb->GetYaxis()->SetBinLabel(15, "#bar{p}");
2386 ha->GetYaxis()->SetBinLabel(15, "#bar{p}");
2387 hb->GetYaxis()->SetBinLabel(16, "K^{0}_{S}");
2388 ha->GetYaxis()->SetBinLabel(16, "K^{0}_{S}");
2389 hb->GetYaxis()->SetBinLabel(17, "#eta");
2390 ha->GetYaxis()->SetBinLabel(17, "#eta");
2391 hb->GetYaxis()->SetBinLabel(18, "#Lambda");
2392 ha->GetYaxis()->SetBinLabel(18, "#Lambda");
2393 hb->GetYaxis()->SetBinLabel(19, "#Sigma^{+}");
2394 ha->GetYaxis()->SetBinLabel(19, "#Sigma^{+}");
2395 hb->GetYaxis()->SetBinLabel(20, "#Sigma^{0}");
2396 ha->GetYaxis()->SetBinLabel(20, "#Sigma^{0}");
2397 hb->GetYaxis()->SetBinLabel(21, "#Sigma^{-}");
2398 ha->GetYaxis()->SetBinLabel(21, "#Sigma^{-}");
2399 hb->GetYaxis()->SetBinLabel(22, "#Theta^{0}");
2400 ha->GetYaxis()->SetBinLabel(22, "#Theta^{0}");
2401 hb->GetYaxis()->SetBinLabel(23, "#Theta^{-}");
2402 ha->GetYaxis()->SetBinLabel(23, "#Theta^{-}");
2403 hb->GetYaxis()->SetBinLabel(24, "#Omega^{-}");
2404 ha->GetYaxis()->SetBinLabel(24, "#Omega^{-}");
2405 hb->GetYaxis()->SetBinLabel(25, "#bar{n}");
2406 ha->GetYaxis()->SetBinLabel(25, "#bar{n}");
2407 hb->GetYaxis()->SetBinLabel(26, "#bar{#Lambda}");
2408 ha->GetYaxis()->SetBinLabel(26, "#bar{#Lambda}");
2409 hb->GetYaxis()->SetBinLabel(27, "#bar{#Sigma}^{-}");
2410 ha->GetYaxis()->SetBinLabel(27, "#bar{#Sigma}^{-}");
2411 hb->GetYaxis()->SetBinLabel(28, "#bar{#Sigma}^{0}");
2412 ha->GetYaxis()->SetBinLabel(28, "#bar{#Sigma}^{0}");
2413 hb->GetYaxis()->SetBinLabel(29, "#bar{#Sigma}^{+}");
2414 ha->GetYaxis()->SetBinLabel(29, "#bar{#Sigma}^{+}");
2415 hb->GetYaxis()->SetBinLabel(30, "#bar{#Theta}^{0}");
2416 ha->GetYaxis()->SetBinLabel(30, "#bar{#Theta}^{0}");
2417 hb->GetYaxis()->SetBinLabel(31, "#bar{#Theta}^{+}");
2418 ha->GetYaxis()->SetBinLabel(31, "#bar{#Theta}^{+}");
2419 hb->GetYaxis()->SetBinLabel(32, "#bar{#Omega}^{+}");
2420 ha->GetYaxis()->SetBinLabel(32, "#bar{#Omega}^{+}");
2421 hb->GetYaxis()->SetBinLabel(33, "#tau^{+}");
2422 ha->GetYaxis()->SetBinLabel(33, "#tau^{+}");
2423 hb->GetYaxis()->SetBinLabel(34, "#tau^{-}");
2424 ha->GetYaxis()->SetBinLabel(34, "#tau^{-}");
2425 hb->GetYaxis()->SetBinLabel(35, "D^{+}");
2426 ha->GetYaxis()->SetBinLabel(35, "D^{+}");
2427 hb->GetYaxis()->SetBinLabel(36, "D^{-}");
2428 ha->GetYaxis()->SetBinLabel(36, "D^{-}");
2429 hb->GetYaxis()->SetBinLabel(37, "D^{0}");
2430 ha->GetYaxis()->SetBinLabel(37, "D^{0}");
2431 hb->GetYaxis()->SetBinLabel(38, "#bar{D}^{0}");
2432 ha->GetYaxis()->SetBinLabel(38, "#bar{D}^{0}");
2433 hb->GetYaxis()->SetBinLabel(39, "D_{s}^{+}");
2434 ha->GetYaxis()->SetBinLabel(39, "D_{s}^{+}");
2435 hb->GetYaxis()->SetBinLabel(40, "#bar{D_{s}}^{-}");
2436 ha->GetYaxis()->SetBinLabel(40, "#bar{D_{s}}^{-}");
2437 hb->GetYaxis()->SetBinLabel(41, "#Lambda_{c}^{+}");
2438 ha->GetYaxis()->SetBinLabel(41, "#Lambda_{c}^{+}");
2439 hb->GetYaxis()->SetBinLabel(42, "W^{+}");
2440 ha->GetYaxis()->SetBinLabel(42, "W^{+}");
2441 hb->GetYaxis()->SetBinLabel(43, "W^{-}");
2442 ha->GetYaxis()->SetBinLabel(43, "W^{-}");
2443 hb->GetYaxis()->SetBinLabel(44, "Z^{0}");
2444 ha->GetYaxis()->SetBinLabel(44, "Z^{0}");
8eca5d19 2445 before->Add(hb);//7
2446 after->Add(ha);//7
2281e7c5 2447
60875c3c 2448 before->Add(new TH2F("TOFkElectron",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//8
2449 after->Add( new TH2F("TOFkElectron",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//8
2450
2451 before->Add(new TH2F("TOFkMuon",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//9
2452 after->Add( new TH2F("TOFkMuon",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//9
2453
2454 before->Add(new TH2F("TOFkPion",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//10
2455 after->Add( new TH2F("TOFkPion",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//10
2456
2457 before->Add(new TH2F("TOFkKaon",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//11
2458 after->Add( new TH2F("TOFkKaon",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//11
2459
2460 before->Add(new TH2F("TOFkProton",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//12
2461 after->Add( new TH2F("TOFkProton",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//12
2462
dd294bb6
MK		 2463 //kink stuff
2464 before->Add(new TH1F("KinkQt",";q_{t}[GeV/c];counts", 200, 0., 0.3));//13
2465 after->Add(new TH1F("KinkQt",";q_{t}[GeV/c];counts", 200, 0., 0.3));//13
2466
2467 before->Add(new TH1F("KinkMinv",";m_{inv}(#mu#nu)[GeV/c^{2}];counts;Kink M_{inv}", 200, 0., 0.7));//14
2468 after->Add(new TH1F("KinkMinv",";m_{inv}(#mu#nu)[GeV/c^{2}];counts;Kink M_{inv}", 200, 0., 0.7));//14
2469
2470 before->Add(new TH2F("KinkVertex",";x[cm];y[cm];Kink vertex position",250,-250.,250., 250,-250.,250.));//15
2471 after->Add(new TH2F("KinkVertex",";x[cm];y[cm];Kink vertex position",250,-250.,250., 250,-250.,250.));//15
2472
2473 before->Add(new TH2F("KinkAngleMp",";p_{mother}[GeV/c];Kink decay angle [deg];", 100,0.,6., 100,0.,80.));//16
2474 after->Add(new TH2F("KinkAngleMp",";p_{mother}[GeV/c];Kink decay angle [deg];", 100,0.,6., 100,0.,80.));//16
2475
2476 before->Add(new TH1F("KinkIndex",";Kink index;counts", 2, 0., 2.));//17
2477 after->Add(new TH1F("KinkIndex",";Kink index;counts", 2, 0., 2.));//17
499fe731 2478 TH1::AddDirectory(adddirstatus);
924b02b0 2479}
9a0783cc 2480
2481//-----------------------------------------------------------------------
2482Int_t AliFlowTrackCuts::GetNumberOfInputObjects() const
2483{
2484 //get the number of tracks in the input event according source
2485 //selection (ESD tracks, tracklets, MC particles etc.)
2486 AliESDEvent* esd=NULL;
2e5052c5 2487 AliAODEvent* aod=NULL; // XZhang 20120615
9a0783cc 2488 switch (fParamType)
2489 {
1a80f9f6 2490 case kSPDtracklet:
2e5052c5 2491 if (!fEvent) return 0; // XZhang 20120615
9a0783cc 2492 esd = dynamic_cast<AliESDEvent*>(fEvent);
2e5052c5 2493 aod = dynamic_cast<AliAODEvent*>(fEvent); // XZhang 20120615
2494// if (!esd) return 0; // XZhang 20120615
2495// return esd->GetMultiplicity()->GetNumberOfTracklets(); // XZhang 20120615
2496 if (esd) return esd->GetMultiplicity()->GetNumberOfTracklets(); // XZhang 20120615
2497 if (aod) return aod->GetTracklets()->GetNumberOfTracklets(); // XZhang 20120615
9a0783cc 2498 case kMC:
2499 if (!fMCevent) return 0;
2500 return fMCevent->GetNumberOfTracks();
d148af7e 2501 case kPMD:
2502 esd = dynamic_cast<AliESDEvent*>(fEvent);
2503 if (!esd) return 0;
2504 return esd->GetNumberOfPmdTracks();
c27333c2
MK		 2505 case kVZERO:
2506 return fgkNumberOfVZEROtracks;
2e5052c5 2507 case kMUON: // XZhang 20120604
2508 if (!fEvent) return 0; // XZhang 20120604
2509 esd = dynamic_cast<AliESDEvent*>(fEvent); // XZhang 20120604
2510 if (esd) return esd->GetNumberOfMuonTracks(); // XZhang 20120604
2511 return fEvent->GetNumberOfTracks(); // if AOD // XZhang 20120604
dd294bb6
MK		 2512 case kKink:
2513 esd = dynamic_cast<AliESDEvent*>(fEvent);
2514 if (!esd) return 0;
2515 return esd->GetNumberOfKinks();
2516 case kV0:
2517 esd = dynamic_cast<AliESDEvent*>(fEvent);
2518 if (!esd) return 0;
2519 return esd->GetNumberOfV0s();
9a0783cc 2520 default:
2521 if (!fEvent) return 0;
2522 return fEvent->GetNumberOfTracks();
2523 }
2524 return 0;
2525}
2526
2527//-----------------------------------------------------------------------
2528TObject* AliFlowTrackCuts::GetInputObject(Int_t i)
2529{
2530 //get the input object according the data source selection:
2531 //(esd tracks, traclets, mc particles,etc...)
2532 AliESDEvent* esd=NULL;
2e5052c5 2533 AliAODEvent* aod=NULL; // XZhang 20120615
9a0783cc 2534 switch (fParamType)
2535 {
1a80f9f6 2536 case kSPDtracklet:
2e5052c5 2537 if (!fEvent) return NULL; // XZhang 20120615
9a0783cc 2538 esd = dynamic_cast<AliESDEvent*>(fEvent);
2e5052c5 2539 aod = dynamic_cast<AliAODEvent*>(fEvent); // XZhang 20120615
2540// if (!esd) return NULL; // XZhang 20120615
2541// return const_cast<AliMultiplicity*>(esd->GetMultiplicity()); // XZhang 20120615
2542 if (esd) return const_cast<AliMultiplicity*>(esd->GetMultiplicity()); // XZhang 20120615
2543 if (aod) return const_cast<AliAODTracklets*>(aod->GetTracklets()); // XZhang 20120615
9a0783cc 2544 case kMC:
2545 if (!fMCevent) return NULL;
2546 return fMCevent->GetTrack(i);
d148af7e 2547 case kPMD:
2548 esd = dynamic_cast<AliESDEvent*>(fEvent);
2549 if (!esd) return NULL;
2550 return esd->GetPmdTrack(i);
c27333c2 2551 case kVZERO:
dd294bb6
MK		 2552 esd = dynamic_cast<AliESDEvent*>(fEvent);
2553 if (!esd) //contributed by G.Ortona
2554 {
2555 aod = dynamic_cast<AliAODEvent*>(fEvent);
2556 if(!aod)return NULL;
2557 return aod->GetVZEROData();
2558 }
2559 return esd->GetVZEROData();
2e5052c5 2560 case kMUON: // XZhang 20120604
2561 if (!fEvent) return NULL; // XZhang 20120604
2562 esd = dynamic_cast<AliESDEvent*>(fEvent); // XZhang 20120604
2563 if (esd) return esd->GetMuonTrack(i); // XZhang 20120604
2564 return fEvent->GetTrack(i); // if AOD // XZhang 20120604
dd294bb6
MK		 2565 case kKink:
2566 esd = dynamic_cast<AliESDEvent*>(fEvent);
2567 if (!esd) return NULL;
2568 return esd->GetKink(i);
2569 case kV0:
2570 esd = dynamic_cast<AliESDEvent*>(fEvent);
2571 if (!esd) return NULL;
2572 return esd->GetV0(i);
9a0783cc 2573 default:
2574 if (!fEvent) return NULL;
2575 return fEvent->GetTrack(i);
2576 }
2577}
a1c43d26 2578
2579//-----------------------------------------------------------------------
2580void AliFlowTrackCuts::Clear(Option_t*)
2581{
2582 //clean up
a1c43d26 2583 fMCevent=NULL;
dd294bb6
MK		 2584 fEvent=NULL;
2585 ClearTrack();
2586}
2587
2588//-----------------------------------------------------------------------
2589void AliFlowTrackCuts::ClearTrack(Option_t*)
2590{
2591 //clean up last track
2592 fKink=NULL;
2593 fV0=NULL;
2594 fTrack=NULL;
a1c43d26 2595 fMCparticle=NULL;
2281e7c5 2596 fTrackLabel=-997;
2597 fTrackWeight=1.0;
a1c43d26 2598 fTrackEta=0.0;
2599 fTrackPhi=0.0;
dd294bb6
MK		 2600 fTrackPt=0.0;
2601 fPOItype=1;
2602 fTrackMass=0.;
a1c43d26 2603}
0d16f553 2604//-----------------------------------------------------------------------
2605Bool_t AliFlowTrackCuts::PassesAODpidCut(const AliAODTrack* track )
2606{
2607 if(!track->GetAODEvent()->GetTOFHeader()){
2608 AliAODPid *pidObj = track->GetDetPid();
2609 if (!pidObj) fESDpid.GetTOFResponse().SetTimeResolution(84.);
2610 else{
2611 Double_t sigmaTOFPidInAOD[10];
2612 pidObj->GetTOFpidResolution(sigmaTOFPidInAOD);
2613 if(sigmaTOFPidInAOD[0] > 84.){
2614 fESDpid.GetTOFResponse().SetTimeResolution(sigmaTOFPidInAOD[0]); // use the electron TOF PID sigma as time resolution (including the T0 used)
2615 }
2616 }
2617 }
2618
2619 //check if passes the selected pid cut for ESDs
2620 Bool_t pass = kTRUE;
2621 switch (fPIDsource)
2622 {
2623 case kTOFbeta:
2624 if (!PassesTOFbetaCut(track)) pass=kFALSE;
2625 break;
2626 case kTOFbayesian:
2627 if (!PassesTOFbayesianCut(track)) pass=kFALSE;
2628 break;
2629 case kTPCbayesian:
2630 if (!PassesTPCbayesianCut(track)) pass=kFALSE;
2631 break;
043e9010 2632 case kTPCTOFNsigma:
2633 if (!PassesTPCTOFNsigmaCut(track)) pass = kFALSE;
2634 break;
0d16f553 2635 default:
2636 return kTRUE;
2637 break;
2638 }
2639 return pass;
32b846cd 2640
0d16f553 2641}
3c67c769 2642//-----------------------------------------------------------------------
2643Bool_t AliFlowTrackCuts::PassesESDpidCut(const AliESDtrack* track )
2644{
2645 //check if passes the selected pid cut for ESDs
2646 Bool_t pass = kTRUE;
2647 switch (fPIDsource)
2648 {
2649 case kTPCpid:
2650 if (!PassesTPCpidCut(track)) pass=kFALSE;
2651 break;
2652 case kTPCdedx:
2653 if (!PassesTPCdedxCut(track)) pass=kFALSE;
2654 break;
2655 case kTOFpid:
2656 if (!PassesTOFpidCut(track)) pass=kFALSE;
2657 break;
2658 case kTOFbeta:
2659 if (!PassesTOFbetaCut(track)) pass=kFALSE;
2660 break;
2661 case kTOFbetaSimple:
2662 if (!PassesTOFbetaSimpleCut(track)) pass=kFALSE;
2663 break;
2664 case kTPCbayesian:
2665 if (!PassesTPCbayesianCut(track)) pass=kFALSE;
2666 break;
2667 // part added by F. Noferini
2668 case kTOFbayesian:
2669 if (!PassesTOFbayesianCut(track)) pass=kFALSE;
2670 break;
2671 // end part added by F. Noferini
2672
2673 //part added by Natasha
2674 case kTPCNuclei:
2675 if (!PassesNucleiSelection(track)) pass=kFALSE;
2676 break;
2677 //end part added by Natasha
d0ce6147 2678
2679 case kTPCTOFNsigma:
2680 if (!PassesTPCTOFNsigmaCut(track)) pass = kFALSE;
2681 break;
3c67c769 2682 default:
2683 printf("AliFlowTrackCuts::PassesCuts() this should never be called!\n");
2684 pass=kFALSE;
2685 break;
2686 }
2687 return pass;
2688}
2689
32b846cd 2690//-----------------------------------------------------------------------
1a80f9f6 2691Bool_t AliFlowTrackCuts::PassesTOFbetaSimpleCut(const AliESDtrack* track )
32b846cd 2692{
2693 //check if passes PID cut using timing in TOF
8b649d8c 2694 Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) &&
b092f828 2695 (track->GetTOFsignal() > 12000) &&
2696 (track->GetTOFsignal() < 100000) &&
499fe731 2697 (track->GetIntegratedLength() > 365);
2698
875ee12a 2699 if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;}
2700
2701 Bool_t statusMatchingHard = TPCTOFagree(track);
2702 if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
2703 return kFALSE;
aab6527a 2704
2705 if (!goodtrack) return kFALSE;
2706
a0241c3a 2707 const Float_t c = 2.99792457999999984e-02;
b092f828 2708 Float_t p = track->GetP();
1a80f9f6 2709 Float_t l = track->GetIntegratedLength();
aab6527a 2710 Float_t trackT0 = fESDpid.GetTOFResponse().GetStartTime(p);
b092f828 2711 Float_t timeTOF = track->GetTOFsignal()- trackT0;
1a80f9f6 2712 Float_t beta = l/timeTOF/c;
80efa607 2713 Double_t integratedTimes[9] = {-1.0,-1.0,-1.0,-1.0,-1.0, -1.0, -1.0, -1.0, -1.0};
1a80f9f6 2714 track->GetIntegratedTimes(integratedTimes);
2715 Float_t betaHypothesis[5] = {0.0,0.0,0.0,0.0,0.0};
2716 Float_t s[5] = {0.0,0.0,0.0,0.0,0.0};
2717 for (Int_t i=0;i<5;i++)
2718 {
2719 betaHypothesis[i] = l/integratedTimes[i]/c;
2720 s[i] = beta-betaHypothesis[i];
2721 }
2722
2723 switch (fParticleID)
2724 {
2725 case AliPID::kPion:
2726 return ( (s[2]<0.015) && (s[2]>-0.015) &&
7288f660 2727 (s[3]>0.025) &&
2728 (s[4]>0.03) );
1a80f9f6 2729 case AliPID::kKaon:
2730 return ( (s[3]<0.015) && (s[3]>-0.015) &&
7288f660 2731 (s[2]<-0.03) &&
2732 (s[4]>0.03) );
1a80f9f6 2733 case AliPID::kProton:
499fe731 2734 return ( (s[4]<0.015) && (s[4]>-0.015) &&
7288f660 2735 (s[3]<-0.025) &&
2736 (s[2]<-0.025) );
1a80f9f6 2737 default:
2738 return kFALSE;
2739 }
2740 return kFALSE;
2741}
2742
499fe731 2743//-----------------------------------------------------------------------
a22c1eb1 2744Float_t AliFlowTrackCuts::GetBeta(const AliVTrack* track, Bool_t QAmode)
499fe731 2745{
2746 //get beta
80efa607 2747 Double_t integratedTimes[9] = {-1.0,-1.0,-1.0,-1.0,-1.0, -1.0, -1.0, -1.0, -1.0};
0d16f553 2748 track->GetIntegratedTimes(integratedTimes);
2749
499fe731 2750 const Float_t c = 2.99792457999999984e-02;
0d16f553 2751 Float_t p = track->P();
2752 Float_t l = integratedTimes[0]*c;
499fe731 2753 Float_t trackT0 = fESDpid.GetTOFResponse().GetStartTime(p);
2754 Float_t timeTOF = track->GetTOFsignal()- trackT0;
a22c1eb1 2755 if(QAmode && timeTOF <= 0) return -999; // avoid division by zero when filling 'before' qa histograms
499fe731 2756 return l/timeTOF/c;
2757}
0d16f553 2758//-----------------------------------------------------------------------
2759Bool_t AliFlowTrackCuts::PassesTOFbetaCut(const AliAODTrack* track )
2760{
2761 //check if track passes pid selection with an asymmetric TOF beta cut
2762 if (!fTOFpidCuts)
2763 {
2764 //printf("no TOFpidCuts\n");
2765 return kFALSE;
2766 }
2767
2768 //check if passes PID cut using timing in TOF
2769 Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) &&
2770 (track->GetTOFsignal() > 12000) &&
2771 (track->GetTOFsignal() < 100000);
2772
2773 if (!goodtrack) return kFALSE;
2774
2775 const Float_t c = 2.99792457999999984e-02;
80efa607 2776 Double_t integratedTimes[9] = {-1.0,-1.0,-1.0,-1.0,-1.0, -1.0, -1.0, -1.0, -1.0};
0d16f553 2777 track->GetIntegratedTimes(integratedTimes);
2778 Float_t l = integratedTimes[0]*c;
499fe731 2779
0d16f553 2780 goodtrack = goodtrack && (l > 365);
2781
2782 if (!goodtrack) return kFALSE;
2783
2784 if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;}
2785
2786 Bool_t statusMatchingHard = TPCTOFagree(track);
2787 if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
2788 return kFALSE;
2789
2790
2791 Float_t beta = GetBeta(track);
2792
2793 //construct the pid index because it's not AliPID::EParticleType
2794 Int_t pid = 0;
2795 switch (fParticleID)
2796 {
2797 case AliPID::kPion:
2798 pid=2;
2799 break;
2800 case AliPID::kKaon:
2801 pid=3;
2802 break;
2803 case AliPID::kProton:
2804 pid=4;
2805 break;
2806 default:
2807 return kFALSE;
2808 }
2809
2810 //signal to cut on
2811 Float_t p = track->P();
2812 Float_t betahypothesis = l/integratedTimes[pid]/c;
2813 Float_t betadiff = beta-betahypothesis;
2814
2815 Float_t* arr = fTOFpidCuts->GetMatrixArray();
2816 Int_t col = TMath::BinarySearch(fTOFpidCuts->GetNcols(),arr,static_cast<Float_t>(p));
2817 if (col<0) return kFALSE;
2818 Float_t min = (*fTOFpidCuts)(1,col);
2819 Float_t max = (*fTOFpidCuts)(2,col);
2820
2821 Bool_t pass = (betadiff>min && betadiff<max);
2822
2823 return pass;
2824}
1a80f9f6 2825//-----------------------------------------------------------------------
2826Bool_t AliFlowTrackCuts::PassesTOFbetaCut(const AliESDtrack* track )
2827{
3c67c769 2828 //check if track passes pid selection with an asymmetric TOF beta cut
9b692328 2829 if (!fTOFpidCuts)
2830 {
2831 //printf("no TOFpidCuts\n");
2832 return kFALSE;
2833 }
2834
1a80f9f6 2835 //check if passes PID cut using timing in TOF
a14b8f3c 2836 Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) &&
1a80f9f6 2837 (track->GetTOFsignal() > 12000) &&
2838 (track->GetTOFsignal() < 100000) &&
499fe731 2839 (track->GetIntegratedLength() > 365);
2840
875ee12a 2841 if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;}
2842
0d16f553 2843 if (!goodtrack) return kFALSE;
2844
875ee12a 2845 Bool_t statusMatchingHard = TPCTOFagree(track);
2846 if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
2847 return kFALSE;
1a80f9f6 2848
499fe731 2849 Float_t beta = GetBeta(track);
80efa607 2850 Double_t integratedTimes[9] = {-1.0,-1.0,-1.0,-1.0,-1.0, -1.0, -1.0, -1.0, -1.0};
a0241c3a 2851 track->GetIntegratedTimes(integratedTimes);
2852
2853 //construct the pid index because it's not AliPID::EParticleType
32b846cd 2854 Int_t pid = 0;
2b1eaa10 2855 switch (fParticleID)
32b846cd 2856 {
2857 case AliPID::kPion:
2858 pid=2;
2859 break;
2860 case AliPID::kKaon:
2861 pid=3;
2862 break;
2863 case AliPID::kProton:
2864 pid=4;
2865 break;
2866 default:
2867 return kFALSE;
2868 }
a0241c3a 2869
2870 //signal to cut on
499fe731 2871 const Float_t c = 2.99792457999999984e-02;
2872 Float_t l = track->GetIntegratedLength();
2873 Float_t p = track->GetP();
1a80f9f6 2874 Float_t betahypothesis = l/integratedTimes[pid]/c;
2875 Float_t betadiff = beta-betahypothesis;
32b846cd 2876
2877 Float_t* arr = fTOFpidCuts->GetMatrixArray();
a0241c3a 2878 Int_t col = TMath::BinarySearch(fTOFpidCuts->GetNcols(),arr,static_cast<Float_t>(p));
32b846cd 2879 if (col<0) return kFALSE;
2880 Float_t min = (*fTOFpidCuts)(1,col);
2881 Float_t max = (*fTOFpidCuts)(2,col);
2882
1a80f9f6 2883 Bool_t pass = (betadiff>min && betadiff<max);
2884
1a80f9f6 2885 return pass;
32b846cd 2886}
2887
2b1eaa10 2888//-----------------------------------------------------------------------
7d27a354 2889Bool_t AliFlowTrackCuts::PassesTOFpidCut(const AliESDtrack* track) const
2b1eaa10 2890{
2891 //check if passes PID cut using default TOF pid
7d27a354 2892 Double_t pidTOF[AliPID::kSPECIES];
2893 track->GetTOFpid(pidTOF);
2894 if (pidTOF[fParticleID]>=fParticleProbability) return kTRUE;
2b1eaa10 2895 return kFALSE;
2896}
2897
32b846cd 2898//-----------------------------------------------------------------------
1a80f9f6 2899Bool_t AliFlowTrackCuts::PassesTPCpidCut(const AliESDtrack* track) const
2b1eaa10 2900{
2901 //check if passes PID cut using default TPC pid
2902 Double_t pidTPC[AliPID::kSPECIES];
2903 track->GetTPCpid(pidTPC);
2904 Double_t probablity = 0.;
2905 switch (fParticleID)
2906 {
2907 case AliPID::kPion:
2908 probablity = pidTPC[AliPID::kPion] + pidTPC[AliPID::kMuon];
2909 break;
2910 default:
2911 probablity = pidTPC[fParticleID];
2912 }
2913 if (probablity >= fParticleProbability) return kTRUE;
2914 return kFALSE;
2915}
2916
499fe731 2917//-----------------------------------------------------------------------
3c67c769 2918Float_t AliFlowTrackCuts::Getdedx(const AliESDtrack* track) const
499fe731 2919{
2920 //get TPC dedx
2921 return track->GetTPCsignal();
2922}
2923
2b1eaa10 2924//-----------------------------------------------------------------------
1a80f9f6 2925Bool_t AliFlowTrackCuts::PassesTPCdedxCut(const AliESDtrack* track)
32b846cd 2926{
2927 //check if passes PID cut using dedx signal in the TPC
32b846cd 2928 if (!fTPCpidCuts)
2929 {
9b692328 2930 //printf("no TPCpidCuts\n");
32b846cd 2931 return kFALSE;
2932 }
2933
3c75bbd5 2934 const AliExternalTrackParam* tpcparam = track->GetInnerParam(); //tpc only params at the inner wall
2935 if (!tpcparam) return kFALSE;
d79d61fb 2936 Double_t p = tpcparam->GetP();
2937 Float_t sigExp = fESDpid.GetTPCResponse().GetExpectedSignal(p, fParticleID);
32b846cd 2938 Float_t sigTPC = track->GetTPCsignal();
2939 Float_t s = (sigTPC-sigExp)/sigExp;
32b846cd 2940
2941 Float_t* arr = fTPCpidCuts->GetMatrixArray();
1a80f9f6 2942 Int_t arrSize = fTPCpidCuts->GetNcols();
2943 Int_t col = TMath::BinarySearch( arrSize, arr, static_cast<Float_t>(p));
32b846cd 2944 if (col<0) return kFALSE;
2945 Float_t min = (*fTPCpidCuts)(1,col);
2946 Float_t max = (*fTPCpidCuts)(2,col);
2947
2948 //printf("------------TPC pid cut %s\n",(s>min && s<max)?"PASS":"FAIL");
2949 return (s>min && s<max);
2950}
2951
2952//-----------------------------------------------------------------------
2953void AliFlowTrackCuts::InitPIDcuts()
2954{
2955 //init matrices with PID cuts
2956 TMatrixF* t = NULL;
2957 if (!fTPCpidCuts)
2958 {
2b1eaa10 2959 if (fParticleID==AliPID::kPion)
32b846cd 2960 {
d79d61fb 2961 t = new TMatrixF(3,15);
2962 (*t)(0,0) = 0.20; (*t)(1,0) = -0.4; (*t)(2,0) = 0.0;
2963 (*t)(0,1) = 0.25; (*t)(1,1) = -0.4; (*t)(2,1) = 0.1;
2964 (*t)(0,2) = 0.30; (*t)(1,2) = -0.4; (*t)(2,2) = 0.2;
2965 (*t)(0,3) = 0.35; (*t)(1,3) = -0.4; (*t)(2,3) = 0.2;
32b846cd 2966 (*t)(0,4) = 0.40; (*t)(1,4) = -0.4; (*t)(2,4) = 0.3;
2967 (*t)(0,5) = 0.45; (*t)(1,5) = -0.4; (*t)(2,5) = 0.3;
2968 (*t)(0,6) = 0.50; (*t)(1,6) = -0.4; (*t)(2,6) = 0.25;
2969 (*t)(0,7) = 0.55; (*t)(1,7) = -0.4; (*t)(2,7) = 0.15;
2970 (*t)(0,8) = 0.60; (*t)(1,8) = -0.4; (*t)(2,8) = 0.1;
d79d61fb 2971 (*t)(0,9) = 0.65; (*t)(1,9) = -0.4; (*t)(2,9) = 0.05;
2972 (*t)(0,10) = 0.70; (*t)(1,10) = -0.4; (*t)(2,10) = 0;
2973 (*t)(0,11) = 0.75; (*t)(1,11) = -0.4; (*t)(2,11) = 0;
2974 (*t)(0,12) = 0.80; (*t)(1,12) = -0.4; (*t)(2,12) = -0.05;
2975 (*t)(0,13) = 0.85; (*t)(1,13) = -0.4; (*t)(2,13) = -0.1;
2976 (*t)(0,14) = 0.90; (*t)(1,14) = 0; (*t)(2,14) = 0;
32b846cd 2977 }
2978 else
2b1eaa10 2979 if (fParticleID==AliPID::kKaon)
3ca4688a 2980 {
d79d61fb 2981 t = new TMatrixF(3,12);
2982 (*t)(0,0) = 0.20; (*t)(1,0) = -0.2; (*t)(2,0) = 0.2;
2983 (*t)(0,1) = 0.25; (*t)(1,1) = -0.2; (*t)(2,1) = 0.2;
2984 (*t)(0,2) = 0.30; (*t)(1,2) = -0.2; (*t)(2,2) = 0.2;
2985 (*t)(0,3) = 0.35; (*t)(1,3) = -0.2; (*t)(2,3) = 0.2;
2986 (*t)(0,4) = 0.40; (*t)(1,4) = -0.1; (*t)(2,4) = 0.2;
2987 (*t)(0,5) = 0.45; (*t)(1,5) = -0.1; (*t)(2,5) = 0.2;
2988 (*t)(0,6) = 0.50; (*t)(1,6) =-0.05; (*t)(2,6) = 0.2;
2989 (*t)(0,7) = 0.55; (*t)(1,7) = -0.1; (*t)(2,7) = 0.1;
2990 (*t)(0,8) = 0.60; (*t)(1,8) =-0.05; (*t)(2,8) = 0.1;
2991 (*t)(0,9) = 0.65; (*t)(1,9) = 0; (*t)(2,9) = 0.15;
2992 (*t)(0,10) = 0.70; (*t)(1,10) = 0.05; (*t)(2,10) = 0.2;
1a80f9f6 2993 (*t)(0,11) = 0.75; (*t)(1,11) = 0; (*t)(2,11) = 0;
3ca4688a 2994 }
2995 else
2b1eaa10 2996 if (fParticleID==AliPID::kProton)
32b846cd 2997 {
d79d61fb 2998 t = new TMatrixF(3,9);
2999 (*t)(0,0) = 0.20; (*t)(1,0) = -0.1; (*t)(2,0) = 0.1;
3000 (*t)(0,1) = 0.25; (*t)(1,1) = -0.2; (*t)(2,1) = 0.2;
3001 (*t)(0,2) = 0.80; (*t)(1,2) = -0.1; (*t)(2,2) = 0.2;
3002 (*t)(0,3) = 0.85; (*t)(1,3) =-0.05; (*t)(2,3) = 0.2;
3003 (*t)(0,4) = 0.90; (*t)(1,4) =-0.05; (*t)(2,4) = 0.25;
3004 (*t)(0,5) = 0.95; (*t)(1,5) =-0.05; (*t)(2,5) = 0.25;
3005 (*t)(0,6) = 1.00; (*t)(1,6) = -0.1; (*t)(2,6) = 0.25;
3006 (*t)(0,7) = 1.10; (*t)(1,7) =-0.05; (*t)(2,7) = 0.3;
3007 (*t)(0,8) = 1.20; (*t)(1,8) = 0; (*t)(2,8) = 0;
32b846cd 3008 }
d79d61fb 3009 delete fTPCpidCuts;
32b846cd 3010 fTPCpidCuts=t;
3011 }
7d9ab4fb 3012 t = NULL;
32b846cd 3013 if (!fTOFpidCuts)
3014 {
2b1eaa10 3015 if (fParticleID==AliPID::kPion)
32b846cd 3016 {
a0241c3a 3017 //TOF pions, 0.9 purity
3018 t = new TMatrixF(3,61);
d79d61fb 3019 (*t)(0,0) = 0.000; (*t)(1,0) = 0.000; (*t)(2,0) = 0.000;
3020 (*t)(0,1) = 0.050; (*t)(1,1) = 0.000; (*t)(2,1) = 0.000;
3021 (*t)(0,2) = 0.100; (*t)(1,2) = 0.000; (*t)(2,2) = 0.000;
3022 (*t)(0,3) = 0.150; (*t)(1,3) = 0.000; (*t)(2,3) = 0.000;
1a80f9f6 3023 (*t)(0,4) = 0.200; (*t)(1,4) = -0.030; (*t)(2,4) = 0.030;
d79d61fb 3024 (*t)(0,5) = 0.250; (*t)(1,5) = -0.036; (*t)(2,5) = 0.032;
3025 (*t)(0,6) = 0.300; (*t)(1,6) = -0.038; (*t)(2,6) = 0.032;
3026 (*t)(0,7) = 0.350; (*t)(1,7) = -0.034; (*t)(2,7) = 0.032;
3027 (*t)(0,8) = 0.400; (*t)(1,8) = -0.032; (*t)(2,8) = 0.020;
3028 (*t)(0,9) = 0.450; (*t)(1,9) = -0.030; (*t)(2,9) = 0.020;
3029 (*t)(0,10) = 0.500; (*t)(1,10) = -0.030; (*t)(2,10) = 0.020;
3030 (*t)(0,11) = 0.550; (*t)(1,11) = -0.030; (*t)(2,11) = 0.020;
3031 (*t)(0,12) = 0.600; (*t)(1,12) = -0.030; (*t)(2,12) = 0.020;
3032 (*t)(0,13) = 0.650; (*t)(1,13) = -0.030; (*t)(2,13) = 0.020;
3033 (*t)(0,14) = 0.700; (*t)(1,14) = -0.030; (*t)(2,14) = 0.020;
3034 (*t)(0,15) = 0.750; (*t)(1,15) = -0.030; (*t)(2,15) = 0.020;
3035 (*t)(0,16) = 0.800; (*t)(1,16) = -0.030; (*t)(2,16) = 0.020;
3036 (*t)(0,17) = 0.850; (*t)(1,17) = -0.030; (*t)(2,17) = 0.020;
3037 (*t)(0,18) = 0.900; (*t)(1,18) = -0.030; (*t)(2,18) = 0.020;
3038 (*t)(0,19) = 0.950; (*t)(1,19) = -0.028; (*t)(2,19) = 0.028;
3039 (*t)(0,20) = 1.000; (*t)(1,20) = -0.028; (*t)(2,20) = 0.028;
3040 (*t)(0,21) = 1.100; (*t)(1,21) = -0.028; (*t)(2,21) = 0.028;
3041 (*t)(0,22) = 1.200; (*t)(1,22) = -0.026; (*t)(2,22) = 0.028;
3042 (*t)(0,23) = 1.300; (*t)(1,23) = -0.024; (*t)(2,23) = 0.028;
3043 (*t)(0,24) = 1.400; (*t)(1,24) = -0.020; (*t)(2,24) = 0.028;
3044 (*t)(0,25) = 1.500; (*t)(1,25) = -0.018; (*t)(2,25) = 0.028;
3045 (*t)(0,26) = 1.600; (*t)(1,26) = -0.016; (*t)(2,26) = 0.028;
3046 (*t)(0,27) = 1.700; (*t)(1,27) = -0.014; (*t)(2,27) = 0.028;
3047 (*t)(0,28) = 1.800; (*t)(1,28) = -0.012; (*t)(2,28) = 0.026;
3048 (*t)(0,29) = 1.900; (*t)(1,29) = -0.010; (*t)(2,29) = 0.026;
3049 (*t)(0,30) = 2.000; (*t)(1,30) = -0.008; (*t)(2,30) = 0.026;
3050 (*t)(0,31) = 2.100; (*t)(1,31) = -0.008; (*t)(2,31) = 0.024;
3051 (*t)(0,32) = 2.200; (*t)(1,32) = -0.006; (*t)(2,32) = 0.024;
3052 (*t)(0,33) = 2.300; (*t)(1,33) = -0.004; (*t)(2,33) = 0.024;
3053 (*t)(0,34) = 2.400; (*t)(1,34) = -0.004; (*t)(2,34) = 0.024;
3054 (*t)(0,35) = 2.500; (*t)(1,35) = -0.002; (*t)(2,35) = 0.024;
3055 (*t)(0,36) = 2.600; (*t)(1,36) = -0.002; (*t)(2,36) = 0.024;
3056 (*t)(0,37) = 2.700; (*t)(1,37) = 0.000; (*t)(2,37) = 0.024;
3057 (*t)(0,38) = 2.800; (*t)(1,38) = 0.000; (*t)(2,38) = 0.026;
3058 (*t)(0,39) = 2.900; (*t)(1,39) = 0.000; (*t)(2,39) = 0.024;
3059 (*t)(0,40) = 3.000; (*t)(1,40) = 0.002; (*t)(2,40) = 0.026;
3060 (*t)(0,41) = 3.100; (*t)(1,41) = 0.002; (*t)(2,41) = 0.026;
3061 (*t)(0,42) = 3.200; (*t)(1,42) = 0.002; (*t)(2,42) = 0.026;
3062 (*t)(0,43) = 3.300; (*t)(1,43) = 0.002; (*t)(2,43) = 0.026;
3063 (*t)(0,44) = 3.400; (*t)(1,44) = 0.002; (*t)(2,44) = 0.026;
3064 (*t)(0,45) = 3.500; (*t)(1,45) = 0.002; (*t)(2,45) = 0.026;
3065 (*t)(0,46) = 3.600; (*t)(1,46) = 0.002; (*t)(2,46) = 0.026;
3066 (*t)(0,47) = 3.700; (*t)(1,47) = 0.002; (*t)(2,47) = 0.026;
3067 (*t)(0,48) = 3.800; (*t)(1,48) = 0.002; (*t)(2,48) = 0.026;
3068 (*t)(0,49) = 3.900; (*t)(1,49) = 0.004; (*t)(2,49) = 0.024;
3069 (*t)(0,50) = 4.000; (*t)(1,50) = 0.004; (*t)(2,50) = 0.026;
3070 (*t)(0,51) = 4.100; (*t)(1,51) = 0.004; (*t)(2,51) = 0.026;
3071 (*t)(0,52) = 4.200; (*t)(1,52) = 0.004; (*t)(2,52) = 0.024;
3072 (*t)(0,53) = 4.300; (*t)(1,53) = 0.006; (*t)(2,53) = 0.024;
3073 (*t)(0,54) = 4.400; (*t)(1,54) = 0.000; (*t)(2,54) = 0.000;
3074 (*t)(0,55) = 4.500; (*t)(1,55) = 0.000; (*t)(2,55) = 0.000;
3075 (*t)(0,56) = 4.600; (*t)(1,56) = 0.000; (*t)(2,56) = 0.000;
3076 (*t)(0,57) = 4.700; (*t)(1,57) = 0.000; (*t)(2,57) = 0.000;
3077 (*t)(0,58) = 4.800; (*t)(1,58) = 0.000; (*t)(2,58) = 0.000;
3078 (*t)(0,59) = 4.900; (*t)(1,59) = 0.000; (*t)(2,59) = 0.000;
3079 (*t)(0,60) = 5.900; (*t)(1,60) = 0.000; (*t)(2,60) = 0.000;
32b846cd 3080 }
3081 else
2b1eaa10 3082 if (fParticleID==AliPID::kProton)
32b846cd 3083 {
a0241c3a 3084 //TOF protons, 0.9 purity
3085 t = new TMatrixF(3,61);
d79d61fb 3086 (*t)(0,0) = 0.000; (*t)(1,0) = 0.000; (*t)(2,0) = 0.000;
3087 (*t)(0,1) = 0.050; (*t)(1,1) = 0.000; (*t)(2,1) = 0.000;
3088 (*t)(0,2) = 0.100; (*t)(1,2) = 0.000; (*t)(2,2) = 0.000;
3089 (*t)(0,3) = 0.150; (*t)(1,3) = 0.000; (*t)(2,3) = 0.000;
1a80f9f6 3090 (*t)(0,4) = 0.200; (*t)(1,4) = -0.07; (*t)(2,4) = 0.07;
3091 (*t)(0,5) = 0.200; (*t)(1,5) = -0.07; (*t)(2,5) = 0.07;
3092 (*t)(0,6) = 0.200; (*t)(1,6) = -0.07; (*t)(2,6) = 0.07;
3093 (*t)(0,7) = 0.200; (*t)(1,7) = -0.07; (*t)(2,7) = 0.07;
3094 (*t)(0,8) = 0.200; (*t)(1,8) = -0.07; (*t)(2,8) = 0.07;
3095 (*t)(0,9) = 0.200; (*t)(1,9) = -0.07; (*t)(2,9) = 0.07;
3096 (*t)(0,10) = 0.200; (*t)(1,10) = -0.07; (*t)(2,10) = 0.07;
3097 (*t)(0,11) = 0.200; (*t)(1,11) = -0.07; (*t)(2,11) = 0.07;
3098 (*t)(0,12) = 0.200; (*t)(1,12) = -0.07; (*t)(2,12) = 0.07;
3099 (*t)(0,13) = 0.200; (*t)(1,13) = -0.07; (*t)(2,13) = 0.07;
3100 (*t)(0,14) = 0.200; (*t)(1,14) = -0.07; (*t)(2,14) = 0.07;
3101 (*t)(0,15) = 0.200; (*t)(1,15) = -0.07; (*t)(2,15) = 0.07;
3102 (*t)(0,16) = 0.200; (*t)(1,16) = -0.07; (*t)(2,16) = 0.07;
d79d61fb 3103 (*t)(0,17) = 0.850; (*t)(1,17) = -0.070; (*t)(2,17) = 0.070;
3104 (*t)(0,18) = 0.900; (*t)(1,18) = -0.072; (*t)(2,18) = 0.072;
3105 (*t)(0,19) = 0.950; (*t)(1,19) = -0.072; (*t)(2,19) = 0.072;
3106 (*t)(0,20) = 1.000; (*t)(1,20) = -0.074; (*t)(2,20) = 0.074;
3107 (*t)(0,21) = 1.100; (*t)(1,21) = -0.032; (*t)(2,21) = 0.032;
3108 (*t)(0,22) = 1.200; (*t)(1,22) = -0.026; (*t)(2,22) = 0.026;
3109 (*t)(0,23) = 1.300; (*t)(1,23) = -0.026; (*t)(2,23) = 0.026;
3110 (*t)(0,24) = 1.400; (*t)(1,24) = -0.024; (*t)(2,24) = 0.024;
3111 (*t)(0,25) = 1.500; (*t)(1,25) = -0.024; (*t)(2,25) = 0.024;
3112 (*t)(0,26) = 1.600; (*t)(1,26) = -0.026; (*t)(2,26) = 0.026;
3113 (*t)(0,27) = 1.700; (*t)(1,27) = -0.026; (*t)(2,27) = 0.026;
3114 (*t)(0,28) = 1.800; (*t)(1,28) = -0.026; (*t)(2,28) = 0.026;
3115 (*t)(0,29) = 1.900; (*t)(1,29) = -0.026; (*t)(2,29) = 0.026;
3116 (*t)(0,30) = 2.000; (*t)(1,30) = -0.026; (*t)(2,30) = 0.026;
3117 (*t)(0,31) = 2.100; (*t)(1,31) = -0.026; (*t)(2,31) = 0.026;
3118 (*t)(0,32) = 2.200; (*t)(1,32) = -0.026; (*t)(2,32) = 0.024;
3119 (*t)(0,33) = 2.300; (*t)(1,33) = -0.028; (*t)(2,33) = 0.022;
3120 (*t)(0,34) = 2.400; (*t)(1,34) = -0.028; (*t)(2,34) = 0.020;
3121 (*t)(0,35) = 2.500; (*t)(1,35) = -0.028; (*t)(2,35) = 0.018;
3122 (*t)(0,36) = 2.600; (*t)(1,36) = -0.028; (*t)(2,36) = 0.016;
3123 (*t)(0,37) = 2.700; (*t)(1,37) = -0.028; (*t)(2,37) = 0.016;
3124 (*t)(0,38) = 2.800; (*t)(1,38) = -0.030; (*t)(2,38) = 0.014;
3125 (*t)(0,39) = 2.900; (*t)(1,39) = -0.030; (*t)(2,39) = 0.012;
3126 (*t)(0,40) = 3.000; (*t)(1,40) = -0.030; (*t)(2,40) = 0.012;
3127 (*t)(0,41) = 3.100; (*t)(1,41) = -0.030; (*t)(2,41) = 0.010;
3128 (*t)(0,42) = 3.200; (*t)(1,42) = -0.030; (*t)(2,42) = 0.010;
3129 (*t)(0,43) = 3.300; (*t)(1,43) = -0.030; (*t)(2,43) = 0.010;
3130 (*t)(0,44) = 3.400; (*t)(1,44) = -0.030; (*t)(2,44) = 0.008;
3131 (*t)(0,45) = 3.500; (*t)(1,45) = -0.030; (*t)(2,45) = 0.008;
3132 (*t)(0,46) = 3.600; (*t)(1,46) = -0.030; (*t)(2,46) = 0.008;
3133 (*t)(0,47) = 3.700; (*t)(1,47) = -0.030; (*t)(2,47) = 0.006;
3134 (*t)(0,48) = 3.800; (*t)(1,48) = -0.030; (*t)(2,48) = 0.006;
3135 (*t)(0,49) = 3.900; (*t)(1,49) = -0.030; (*t)(2,49) = 0.006;
3136 (*t)(0,50) = 4.000; (*t)(1,50) = -0.028; (*t)(2,50) = 0.004;
3137 (*t)(0,51) = 4.100; (*t)(1,51) = -0.030; (*t)(2,51) = 0.004;
3138 (*t)(0,52) = 4.200; (*t)(1,52) = -0.030; (*t)(2,52) = 0.004;
3139 (*t)(0,53) = 4.300; (*t)(1,53) = -0.028; (*t)(2,53) = 0.002;
3140 (*t)(0,54) = 4.400; (*t)(1,54) = -0.030; (*t)(2,54) = 0.002;
3141 (*t)(0,55) = 4.500; (*t)(1,55) = -0.028; (*t)(2,55) = 0.002;
3142 (*t)(0,56) = 4.600; (*t)(1,56) = -0.028; (*t)(2,56) = 0.002;
3143 (*t)(0,57) = 4.700; (*t)(1,57) = -0.028; (*t)(2,57) = 0.000;
3144 (*t)(0,58) = 4.800; (*t)(1,58) = -0.028; (*t)(2,58) = 0.002;
3145 (*t)(0,59) = 4.900; (*t)(1,59) = 0.000; (*t)(2,59) = 0.000;
3146 (*t)(0,60) = 5.900; (*t)(1,60) = 0.000; (*t)(2,60) = 0.000;
32b846cd 3147 }
3148 else
2b1eaa10 3149 if (fParticleID==AliPID::kKaon)
32b846cd 3150 {
a0241c3a 3151 //TOF kaons, 0.9 purity
3152 t = new TMatrixF(3,61);
d79d61fb 3153 (*t)(0,0) = 0.000; (*t)(1,0) = 0.000; (*t)(2,0) = 0.000;
3154 (*t)(0,1) = 0.050; (*t)(1,1) = 0.000; (*t)(2,1) = 0.000;
3155 (*t)(0,2) = 0.100; (*t)(1,2) = 0.000; (*t)(2,2) = 0.000;
3156 (*t)(0,3) = 0.150; (*t)(1,3) = 0.000; (*t)(2,3) = 0.000;
1a80f9f6 3157 (*t)(0,4) = 0.200; (*t)(1,4) = -0.05; (*t)(2,4) = 0.05;
3158 (*t)(0,5) = 0.200; (*t)(1,5) = -0.05; (*t)(2,5) = 0.05;
3159 (*t)(0,6) = 0.200; (*t)(1,6) = -0.05; (*t)(2,6) = 0.05;
3160 (*t)(0,7) = 0.200; (*t)(1,7) = -0.05; (*t)(2,7) = 0.05;
3161 (*t)(0,8) = 0.200; (*t)(1,8) = -0.05; (*t)(2,8) = 0.05;
3162 (*t)(0,9) = 0.200; (*t)(1,9) = -0.05; (*t)(2,9) = 0.05;
3163 (*t)(0,10) = 0.200; (*t)(1,10) = -0.05; (*t)(2,10) = 0.05;
d79d61fb 3164 (*t)(0,11) = 0.550; (*t)(1,11) = -0.026; (*t)(2,11) = 0.026;
3165 (*t)(0,12) = 0.600; (*t)(1,12) = -0.026; (*t)(2,12) = 0.026;
3166 (*t)(0,13) = 0.650; (*t)(1,13) = -0.026; (*t)(2,13) = 0.026;
3167 (*t)(0,14) = 0.700; (*t)(1,14) = -0.026; (*t)(2,14) = 0.026;
3168 (*t)(0,15) = 0.750; (*t)(1,15) = -0.026; (*t)(2,15) = 0.026;
3169 (*t)(0,16) = 0.800; (*t)(1,16) = -0.026; (*t)(2,16) = 0.026;
3170 (*t)(0,17) = 0.850; (*t)(1,17) = -0.024; (*t)(2,17) = 0.024;
3171 (*t)(0,18) = 0.900; (*t)(1,18) = -0.024; (*t)(2,18) = 0.024;
3172 (*t)(0,19) = 0.950; (*t)(1,19) = -0.024; (*t)(2,19) = 0.024;
3173 (*t)(0,20) = 1.000; (*t)(1,20) = -0.024; (*t)(2,20) = 0.024;
3174 (*t)(0,21) = 1.100; (*t)(1,21) = -0.024; (*t)(2,21) = 0.024;
3175 (*t)(0,22) = 1.200; (*t)(1,22) = -0.024; (*t)(2,22) = 0.022;
3176 (*t)(0,23) = 1.300; (*t)(1,23) = -0.024; (*t)(2,23) = 0.020;
3177 (*t)(0,24) = 1.400; (*t)(1,24) = -0.026; (*t)(2,24) = 0.016;
3178 (*t)(0,25) = 1.500; (*t)(1,25) = -0.028; (*t)(2,25) = 0.014;
3179 (*t)(0,26) = 1.600; (*t)(1,26) = -0.028; (*t)(2,26) = 0.012;
3180 (*t)(0,27) = 1.700; (*t)(1,27) = -0.028; (*t)(2,27) = 0.010;
3181 (*t)(0,28) = 1.800; (*t)(1,28) = -0.028; (*t)(2,28) = 0.010;
3182 (*t)(0,29) = 1.900; (*t)(1,29) = -0.028; (*t)(2,29) = 0.008;
3183 (*t)(0,30) = 2.000; (*t)(1,30) = -0.028; (*t)(2,30) = 0.006;
3184 (*t)(0,31) = 2.100; (*t)(1,31) = -0.026; (*t)(2,31) = 0.006;
3185 (*t)(0,32) = 2.200; (*t)(1,32) = -0.024; (*t)(2,32) = 0.004;
3186 (*t)(0,33) = 2.300; (*t)(1,33) = -0.020; (*t)(2,33) = 0.002;
3187 (*t)(0,34) = 2.400; (*t)(1,34) = -0.020; (*t)(2,34) = 0.002;
3188 (*t)(0,35) = 2.500; (*t)(1,35) = -0.018; (*t)(2,35) = 0.000;
3189 (*t)(0,36) = 2.600; (*t)(1,36) = -0.016; (*t)(2,36) = 0.000;
3190 (*t)(0,37) = 2.700; (*t)(1,37) = -0.014; (*t)(2,37) = -0.002;
3191 (*t)(0,38) = 2.800; (*t)(1,38) = -0.014; (*t)(2,38) = -0.004;
3192 (*t)(0,39) = 2.900; (*t)(1,39) = -0.012; (*t)(2,39) = -0.004;
3193 (*t)(0,40) = 3.000; (*t)(1,40) = -0.010; (*t)(2,40) = -0.006;
3194 (*t)(0,41) = 3.100; (*t)(1,41) = 0.000; (*t)(2,41) = 0.000;
3195 (*t)(0,42) = 3.200; (*t)(1,42) = 0.000; (*t)(2,42) = 0.000;
3196 (*t)(0,43) = 3.300; (*t)(1,43) = 0.000; (*t)(2,43) = 0.000;
3197 (*t)(0,44) = 3.400; (*t)(1,44) = 0.000; (*t)(2,44) = 0.000;
3198 (*t)(0,45) = 3.500; (*t)(1,45) = 0.000; (*t)(2,45) = 0.000;
3199 (*t)(0,46) = 3.600; (*t)(1,46) = 0.000; (*t)(2,46) = 0.000;
3200 (*t)(0,47) = 3.700; (*t)(1,47) = 0.000; (*t)(2,47) = 0.000;
3201 (*t)(0,48) = 3.800; (*t)(1,48) = 0.000; (*t)(2,48) = 0.000;
3202 (*t)(0,49) = 3.900; (*t)(1,49) = 0.000; (*t)(2,49) = 0.000;
3203 (*t)(0,50) = 4.000; (*t)(1,50) = 0.000; (*t)(2,50) = 0.000;
3204 (*t)(0,51) = 4.100; (*t)(1,51) = 0.000; (*t)(2,51) = 0.000;
3205 (*t)(0,52) = 4.200; (*t)(1,52) = 0.000; (*t)(2,52) = 0.000;
3206 (*t)(0,53) = 4.300; (*t)(1,53) = 0.000; (*t)(2,53) = 0.000;
3207 (*t)(0,54) = 4.400; (*t)(1,54) = 0.000; (*t)(2,54) = 0.000;
3208 (*t)(0,55) = 4.500; (*t)(1,55) = 0.000; (*t)(2,55) = 0.000;
3209 (*t)(0,56) = 4.600; (*t)(1,56) = 0.000; (*t)(2,56) = 0.000;
3210 (*t)(0,57) = 4.700; (*t)(1,57) = 0.000; (*t)(2,57) = 0.000;
3211 (*t)(0,58) = 4.800; (*t)(1,58) = 0.000; (*t)(2,58) = 0.000;
3212 (*t)(0,59) = 4.900; (*t)(1,59) = 0.000; (*t)(2,59) = 0.000;
3213 (*t)(0,60) = 5.900; (*t)(1,60) = 0.000; (*t)(2,60) = 0.000;
32b846cd 3214 }
d79d61fb 3215 delete fTOFpidCuts;
32b846cd 3216 fTOFpidCuts=t;
3217 }
3218}
3abf7ecc 3219
0d16f553 3220//-----------------------------------------------------------------------
3221//-----------------------------------------------------------------------
3222Bool_t AliFlowTrackCuts::PassesTPCbayesianCut(const AliAODTrack* track)
3223{
3224 fBayesianResponse->ComputeProb(track,track->GetAODEvent()); // fCurrCentr is needed for mismatch fraction
3225 Float_t *probabilities = fBayesianResponse->GetProb(); // Bayesian Probability (from 0 to 4) (Combined TPC || TOF) including a tuning of priors and TOF mism$
3226
3227 Int_t kTPC = fBayesianResponse->GetCurrentMask(0); // is TPC on
3228
3229 if(! kTPC) return kFALSE;
3230
3231 fProbBayes = 0.0;
3232
3233switch (fParticleID)
3234 {
3235 case AliPID::kPion:
3236 fProbBayes = probabilities[2];
3237 break;
3238 case AliPID::kKaon:
3239 fProbBayes = probabilities[3];
3240 break;
3241 case AliPID::kProton:
3242 fProbBayes = probabilities[4];
3243 break;
3244 case AliPID::kElectron:
3245 fProbBayes = probabilities[0];
3246 break;
3247 case AliPID::kMuon:
3248 fProbBayes = probabilities[1];
3249 break;
3250 case AliPID::kDeuteron:
3251 fProbBayes = probabilities[5];
3252 break;
3253 case AliPID::kTriton:
3254 fProbBayes = probabilities[6];
3255 break;
3256 case AliPID::kHe3:
3257 fProbBayes = probabilities[7];
3258 break;
3259 default:
3260 return kFALSE;
3261 }
3262
3263 if(fProbBayes > fParticleProbability){
3264 if(!fCutCharge)
3265 return kTRUE;
3266 else if (fCutCharge && fCharge * track->Charge() > 0)
3267 return kTRUE;
3268 }
3269 return kFALSE;
3270}
cd62a2a8 3271//-----------------------------------------------------------------------
3272Bool_t AliFlowTrackCuts::PassesTPCbayesianCut(const AliESDtrack* track)
3273{
3274 //cut on TPC bayesian pid
cd62a2a8 3275 //if (! fAllowTOFmismatchFlag) {if (track->GetStatus() & AliESDtrack::kTOFmismatch) return kFALSE;}
3276
3277 //Bool_t statusMatchingHard = TPCTOFagree(track);
3278 //if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
3279 // return kFALSE;
8b649d8c 3280 fBayesianResponse->ComputeProb(track,fCurrCentr); // fCurrCentr is needed for mismatch fraction
9126fd0c 3281 Int_t kTPC = fBayesianResponse->GetCurrentMask(0); // is TPC on
0d16f553 3282 //Int_t kTOF = fBayesianResponse->GetCurrentMask(1); // is TOF on
cd62a2a8 3283
9126fd0c 3284 if(! kTPC) return kFALSE;
3285
0d16f553 3286 // Bool_t statusMatchingHard = 1;
3287 // Float_t mismProb = 0;
3288 // if(kTOF){
3289 // statusMatchingHard = TPCTOFagree(track);
3290 // mismProb = fBayesianResponse->GetTOFMismProb();
3291 // }
3292 // if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
3293 // return kFALSE;
9126fd0c 3294
9126fd0c 3295 Float_t *probabilities = fBayesianResponse->GetProb(); // Bayesian Probability (from 0 to 4) (Combined TPC || TOF) including a tuning of priors and TOF mismatch parameterization
3296
8b649d8c 3297 fProbBayes = 0.0;
cd62a2a8 3298
cd62a2a8 3299 switch (fParticleID)
3300 {
3301 case AliPID::kPion:
8b649d8c 3302 fProbBayes = probabilities[2];
cd62a2a8 3303 break;
3304 case AliPID::kKaon:
8b649d8c 3305 fProbBayes = probabilities[3];
cd62a2a8 3306 break;
3307 case AliPID::kProton:
8b649d8c 3308 fProbBayes = probabilities[4];
cd62a2a8 3309 break;
3310 case AliPID::kElectron:
8b649d8c 3311 fProbBayes = probabilities[0];
3312 break;
3313 case AliPID::kMuon:
3314 fProbBayes = probabilities[1];
3315 break;
3316 case AliPID::kDeuteron:
3317 fProbBayes = probabilities[5];
3318 break;
3319 case AliPID::kTriton:
3320 fProbBayes = probabilities[6];
3321 break;
3322 case AliPID::kHe3:
3323 fProbBayes = probabilities[7];
cd62a2a8 3324 break;
3325 default:
3326 return kFALSE;
3327 }
3328
0d16f553 3329 if(fProbBayes > fParticleProbability)
9126fd0c 3330 {
3331 if(!fCutCharge)
3332 return kTRUE;
3333 else if (fCutCharge && fCharge * track->GetSign() > 0)
3334 return kTRUE;
3335 }
cd62a2a8 3336 return kFALSE;
3337}
0d16f553 3338//-----------------------------------------------------------------------
3339Bool_t AliFlowTrackCuts::PassesTOFbayesianCut(const AliAODTrack* track)
3340{
a22c1eb1 3341 //check is track passes bayesian combined TOF+TPC pid cut
0d16f553 3342 Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFout) &&
3343 (track->GetStatus() & AliESDtrack::kTIME) &&
3344 (track->GetTOFsignal() > 12000) &&
3345 (track->GetTOFsignal() < 100000);
cd62a2a8 3346
0d16f553 3347 if (! goodtrack)
3348 return kFALSE;
3349
3350 Bool_t statusMatchingHard = TPCTOFagree(track);
0d16f553 3351 if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
3352 return kFALSE;
3353
3354 fBayesianResponse->ComputeProb(track,track->GetAODEvent()); // fCurrCentr is needed for mismatch fraction
3355 Float_t *probabilities = fBayesianResponse->GetProb(); // Bayesian Probability (from 0 to 4) (Combined TPC || TOF) including a tuning of priors and TOF mism$
3356
3357 Float_t mismProb = fBayesianResponse->GetTOFMismProb(); // mismatch Bayesian probabilities
3358
3359 fProbBayes = 0.0;
3360
3361 switch (fParticleID)
3362 {
3363 case AliPID::kPion:
3364 fProbBayes = probabilities[2];
3365 break;
3366 case AliPID::kKaon:
3367 fProbBayes = probabilities[3];
3368 break;
3369 case AliPID::kProton:
3370 fProbBayes = probabilities[4];
3371 break;
3372 case AliPID::kElectron:
3373 fProbBayes = probabilities[0];
3374 break;
3375 case AliPID::kMuon:
3376 fProbBayes = probabilities[1];
3377 break;
3378 case AliPID::kDeuteron:
3379 fProbBayes = probabilities[5];
3380 break;
3381 case AliPID::kTriton:
3382 fProbBayes = probabilities[6];
3383 break;
3384 case AliPID::kHe3:
3385 fProbBayes = probabilities[7];
3386 break;
3387 default:
3388 return kFALSE;
3389 }
3390
3391 if(fProbBayes > fParticleProbability && mismProb < 0.5){
3392 if(!fCutCharge)
3393 return kTRUE;
3394 else if (fCutCharge && fCharge * track->Charge() > 0)
3395 return kTRUE;
3396 }
3397 return kFALSE;
3398
3399}
3abf7ecc 3400//-----------------------------------------------------------------------
3401// part added by F. Noferini (some methods)
cd62a2a8 3402Bool_t AliFlowTrackCuts::PassesTOFbayesianCut(const AliESDtrack* track)
875ee12a 3403{
3c67c769 3404 //check is track passes bayesian combined TOF+TPC pid cut
8b649d8c 3405 Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFout) &&
3406 (track->GetStatus() & AliESDtrack::kTIME) &&
875ee12a 3407 (track->GetTOFsignal() > 12000) &&
3408 (track->GetTOFsignal() < 100000) &&
3409 (track->GetIntegratedLength() > 365);
3abf7ecc 3410
3abf7ecc 3411 if (! goodtrack)
3412 return kFALSE;
3413
6a043318 3414 if (! fAllowTOFmismatchFlag) {if (track->GetStatus() & AliESDtrack::kTOFmismatch) return kFALSE;}
3415
875ee12a 3416 Bool_t statusMatchingHard = TPCTOFagree(track);
3417 if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
3418 return kFALSE;
3419
9126fd0c 3420 fBayesianResponse->ComputeProb(track,fCurrCentr); // fCurrCentr is needed for mismatch fraction
3421 Float_t *probabilities = fBayesianResponse->GetProb(); // Bayesian Probability (from 0 to 4) (Combined TPC || TOF) including a tuning of priors and TOF mismatch parameterization
3422
9126fd0c 3423 Float_t mismProb = fBayesianResponse->GetTOFMismProb(); // mismatch Bayesian probabilities
3abf7ecc 3424
8b649d8c 3425 fProbBayes = 0.0;
3426
2b1eaa10 3427 switch (fParticleID)
3abf7ecc 3428 {
3429 case AliPID::kPion:
8b649d8c 3430 fProbBayes = probabilities[2];
3abf7ecc 3431 break;
3432 case AliPID::kKaon:
8b649d8c 3433 fProbBayes = probabilities[3];
3abf7ecc 3434 break;
3435 case AliPID::kProton:
8b649d8c 3436 fProbBayes = probabilities[4];
3abf7ecc 3437 break;
3438 case AliPID::kElectron:
8b649d8c 3439 fProbBayes = probabilities[0];
3abf7ecc 3440 break;
8b649d8c 3441 case AliPID::kMuon:
3442 fProbBayes = probabilities[1];
3443 break;
3444 case AliPID::kDeuteron:
3445 fProbBayes = probabilities[5];
3446 break;
3447 case AliPID::kTriton:
3448 fProbBayes = probabilities[6];
3449 break;
3450 case AliPID::kHe3:
3451 fProbBayes = probabilities[7];
3452 break;
3453 default:
3abf7ecc 3454 return kFALSE;
3455 }
3456
3457 // printf("pt = %f -- all prob = [%4.2f,%4.2f,%4.2f,%4.2f,%4.2f] -- prob = %f\n",track->Pt(),fProbBayes[0],fProbBayes[1],fProbBayes[2],fProbBayes[3],fProbBayes[4],prob);
8b649d8c 3458 if(fProbBayes > fParticleProbability && mismProb < 0.5){
3abf7ecc 3459 if(!fCutCharge)
3460 return kTRUE;
3461 else if (fCutCharge && fCharge * track->GetSign() > 0)
3462 return kTRUE;
3463 }
3464 return kFALSE;
3465}
875ee12a 3466
8eca5d19 3467
3468//-----------------------------------------------------------------------
3469 // part added by Natasha
3470Bool_t AliFlowTrackCuts::PassesNucleiSelection(const AliESDtrack* track)
3471{
3c67c769 3472 //pid selection for heavy nuclei
8eca5d19 3473 Bool_t select=kFALSE;
3474
3475 //if (!track) continue;
6887199d 3476
8eca5d19 3477 if (!track->GetInnerParam())
3478 return kFALSE; //break;
6887199d 3479
8eca5d19 3480 const AliExternalTrackParam* tpcTrack = track->GetInnerParam();
6887199d 3481
8eca5d19 3482 Double_t ptotTPC = tpcTrack->GetP();
3483 Double_t sigTPC = track->GetTPCsignal();
3484 Double_t dEdxBBA = 0.;
3485 Double_t dSigma = 0.;
3486
3487 switch (fParticleID)
6887199d 3488 {
8eca5d19 3489 case AliPID::kDeuteron:
3490 //pid=10;
3491 dEdxBBA = AliExternalTrackParam::BetheBlochAleph(ptotTPC/1.8756,
6887199d 3492 4.60e+00,
3493 8.9684e+00,
3494 1.640e-05,
3495 2.35e+00,
3496 2.35e+00);
8eca5d19 3497 dSigma = (sigTPC - dEdxBBA)/dEdxBBA;
6887199d 3498
8eca5d19 3499 if( ptotTPC<=1.1 && (dSigma < (0.5 - (0.1818*ptotTPC)) ) && (dSigma > ( (0.218*ptotTPC - 0.4) ) ) )
6887199d 3500 {select=kTRUE;}
8eca5d19 3501 break;
6887199d 3502
8eca5d19 3503 case AliPID::kTriton:
3504 //pid=11;
3505 select=kFALSE;
3506 break;
6887199d 3507
8eca5d19 3508 case AliPID::kHe3:
3509 //pid=12;
6887199d 3510 // ----- Pass 2 -------
3511 dEdxBBA = 4.0 * AliExternalTrackParam::BetheBlochAleph( (2.*ptotTPC)/2.8084,
3512 1.74962,
3513 27.4992,
3514 4.00313e-15,
3515 2.42485,
3516 8.31768);
3517 dSigma = (sigTPC - dEdxBBA)/dEdxBBA;
3518 if(ptotTPC<=5.0 && (dSigma >= (-0.03968*ptotTPC - 0.1)) && (dSigma <= (0.31 - 0.0217*ptotTPC)))
3519 {select=kTRUE;}
8eca5d19 3520 break;
6887199d 3521
8eca5d19 3522 case AliPID::kAlpha:
3523 //pid=13;
3524 select=kFALSE;
3525 break;
6887199d 3526
8eca5d19 3527 default:
3528 return kFALSE;
6887199d 3529 }
3530
8eca5d19 3531 return select;
3532}
3533// end part added by Natasha
d0ce6147 3534//-----------------------------------------------------------------------
3535Bool_t AliFlowTrackCuts::PassesTPCTOFNsigmaCut(const AliAODTrack* track)
3536{
3537 // do a simple combined cut on the n sigma from tpc and tof
3538 // with information of the pid response object (needs pid response task)
3539 // stub, not implemented yet
043e9010 3540 if(!fPIDResponse) return kFALSE;
d0ce6147 3541 if(!track) return kFALSE;
043e9010 3542
3543 // check TOF status
3544 if ((track->GetStatus()&AliVTrack::kTOFout)==0) return kFALSE;
3545 if ((track->GetStatus()&AliVTrack::kTIME)==0) return kFALSE;
3546
3547 // check TPC status
3548 if(track->GetTPCsignal() < 10) return kFALSE;
3549
3550 Float_t nsigmaTPC = fPIDResponse->NumberOfSigmas(AliPIDResponse::kTPC,track,fParticleID);
3551 Float_t nsigmaTOF = fPIDResponse->NumberOfSigmas(AliPIDResponse::kTOF,track,fParticleID);
3552
3553 Float_t nsigma2 = nsigmaTPC*nsigmaTPC + nsigmaTOF*nsigmaTOF;
3554
3555 return (nsigma2 < fNsigmaCut2);
d0ce6147 3556
3557}
3558//-----------------------------------------------------------------------------
3559Bool_t AliFlowTrackCuts::PassesTPCTOFNsigmaCut(const AliESDtrack* track)
3560{
3561 // do a simple combined cut on the n sigma from tpc and tof
3562 // with information of the pid response object (needs pid response task)
3563 // stub, not implemented yet
043e9010 3564 if(!fPIDResponse) return kFALSE;
d0ce6147 3565 if(!track) return kFALSE;
043e9010 3566
3567 // check TOF status
3568 if ((track->GetStatus()&AliVTrack::kTOFout)==0) return kFALSE;
3569 if ((track->GetStatus()&AliVTrack::kTIME)==0) return kFALSE;
3570
3571 // check TPC status
3572 if(track->GetTPCsignal() < 10) return kFALSE;
3573
3574 Float_t nsigmaTPC = fPIDResponse->NumberOfSigmas(AliPIDResponse::kTPC,track,fParticleID);
3575 Float_t nsigmaTOF = fPIDResponse->NumberOfSigmas(AliPIDResponse::kTOF,track,fParticleID);
3576
3577 Float_t nsigma2 = nsigmaTPC*nsigmaTPC + nsigmaTOF*nsigmaTOF;
3578
3579 return (nsigma2 < fNsigmaCut2);
d0ce6147 3580
3581}
3582
3abf7ecc 3583//-----------------------------------------------------------------------
875ee12a 3584void AliFlowTrackCuts::SetPriors(Float_t centrCur){
cc0afcfc 3585 //set priors for the bayesian pid selection
9126fd0c 3586 fCurrCentr = centrCur;
3587
875ee12a 3588 fBinLimitPID[0] = 0.300000;
3589 fBinLimitPID[1] = 0.400000;
3590 fBinLimitPID[2] = 0.500000;
3591 fBinLimitPID[3] = 0.600000;
3592 fBinLimitPID[4] = 0.700000;
3593 fBinLimitPID[5] = 0.800000;
3594 fBinLimitPID[6] = 0.900000;
3595 fBinLimitPID[7] = 1.000000;
3596 fBinLimitPID[8] = 1.200000;
3597 fBinLimitPID[9] = 1.400000;
3598 fBinLimitPID[10] = 1.600000;
3599 fBinLimitPID[11] = 1.800000;
3600 fBinLimitPID[12] = 2.000000;
3601 fBinLimitPID[13] = 2.200000;
3602 fBinLimitPID[14] = 2.400000;
3603 fBinLimitPID[15] = 2.600000;
3604 fBinLimitPID[16] = 2.800000;
3605 fBinLimitPID[17] = 3.000000;
3606
3607 // 0-10%
3608 if(centrCur < 10){
3609 fC[0][0] = 0.005;
3610 fC[0][1] = 0.005;
3611 fC[0][2] = 1.0000;
3612 fC[0][3] = 0.0010;
3613 fC[0][4] = 0.0010;
3614
3615 fC[1][0] = 0.005;
3616 fC[1][1] = 0.005;
3617 fC[1][2] = 1.0000;
3618 fC[1][3] = 0.0168;
3619 fC[1][4] = 0.0122;
3620
3621 fC[2][0] = 0.005;
3622 fC[2][1] = 0.005;
3623 fC[2][2] = 1.0000;
3624 fC[2][3] = 0.0272;
3625 fC[2][4] = 0.0070;
3626
3627 fC[3][0] = 0.005;
3628 fC[3][1] = 0.005;
3629 fC[3][2] = 1.0000;
3630 fC[3][3] = 0.0562;
3631 fC[3][4] = 0.0258;
3632
3633 fC[4][0] = 0.005;
3634 fC[4][1] = 0.005;
3635 fC[4][2] = 1.0000;
3636 fC[4][3] = 0.0861;
3637 fC[4][4] = 0.0496;
3638
3639 fC[5][0] = 0.005;
3640 fC[5][1] = 0.005;
3641 fC[5][2] = 1.0000;
3642 fC[5][3] = 0.1168;
3643 fC[5][4] = 0.0740;
3644
3645 fC[6][0] = 0.005;
3646 fC[6][1] = 0.005;
3647 fC[6][2] = 1.0000;
3648 fC[6][3] = 0.1476;
3649 fC[6][4] = 0.0998;
3650
3651 fC[7][0] = 0.005;
3652 fC[7][1] = 0.005;
3653 fC[7][2] = 1.0000;
3654 fC[7][3] = 0.1810;
3655 fC[7][4] = 0.1296;
3656
3657 fC[8][0] = 0.005;
3658 fC[8][1] = 0.005;
3659 fC[8][2] = 1.0000;
3660 fC[8][3] = 0.2240;
3661 fC[8][4] = 0.1827;
3662
3663 fC[9][0] = 0.005;
3664 fC[9][1] = 0.005;
3665 fC[9][2] = 1.0000;
3666 fC[9][3] = 0.2812;
3667 fC[9][4] = 0.2699;
3668
3669 fC[10][0] = 0.005;
3670 fC[10][1] = 0.005;
3671 fC[10][2] = 1.0000;
3672 fC[10][3] = 0.3328;
3673 fC[10][4] = 0.3714;
3674
3675 fC[11][0] = 0.005;
3676 fC[11][1] = 0.005;
3677 fC[11][2] = 1.0000;
3678 fC[11][3] = 0.3780;
3679 fC[11][4] = 0.4810;
3680
3681 fC[12][0] = 0.005;
3682 fC[12][1] = 0.005;
3683 fC[12][2] = 1.0000;
3684 fC[12][3] = 0.4125;
3685 fC[12][4] = 0.5771;
3686
3687 fC[13][0] = 0.005;
3688 fC[13][1] = 0.005;
3689 fC[13][2] = 1.0000;
3690 fC[13][3] = 0.4486;
3691 fC[13][4] = 0.6799;
3692
3693 fC[14][0] = 0.005;
3694 fC[14][1] = 0.005;
3695 fC[14][2] = 1.0000;
3696 fC[14][3] = 0.4840;
3697 fC[14][4] = 0.7668;
3698
3699 fC[15][0] = 0.005;
3700 fC[15][1] = 0.005;
3701 fC[15][2] = 1.0000;
3702 fC[15][3] = 0.4971;
3703 fC[15][4] = 0.8288;
3704
3705 fC[16][0] = 0.005;
3706 fC[16][1] = 0.005;
3707 fC[16][2] = 1.0000;
3708 fC[16][3] = 0.4956;
3709 fC[16][4] = 0.8653;
3710
3711 fC[17][0] = 0.005;
3712 fC[17][1] = 0.005;
3713 fC[17][2] = 1.0000;
3714 fC[17][3] = 0.5173;
3715 fC[17][4] = 0.9059;
3716 }
3717 // 10-20%
3718 else if(centrCur < 20){
3719 fC[0][0] = 0.005;
3720 fC[0][1] = 0.005;
3721 fC[0][2] = 1.0000;
3722 fC[0][3] = 0.0010;
3723 fC[0][4] = 0.0010;
3724
3725 fC[1][0] = 0.005;
3726 fC[1][1] = 0.005;
3727 fC[1][2] = 1.0000;
3728 fC[1][3] = 0.0132;
3729 fC[1][4] = 0.0088;
3730
3731 fC[2][0] = 0.005;
3732 fC[2][1] = 0.005;
3733 fC[2][2] = 1.0000;
3734 fC[2][3] = 0.0283;
3735 fC[2][4] = 0.0068;
3736
3737 fC[3][0] = 0.005;
3738 fC[3][1] = 0.005;
3739 fC[3][2] = 1.0000;
3740 fC[3][3] = 0.0577;
3741 fC[3][4] = 0.0279;
3742
3743 fC[4][0] = 0.005;
3744 fC[4][1] = 0.005;
3745 fC[4][2] = 1.0000;
3746 fC[4][3] = 0.0884;
3747 fC[4][4] = 0.0534;
3748
3749 fC[5][0] = 0.005;
3750 fC[5][1] = 0.005;
3751 fC[5][2] = 1.0000;
3752 fC[5][3] = 0.1179;
3753 fC[5][4] = 0.0794;
3754
3755 fC[6][0] = 0.005;
3756 fC[6][1] = 0.005;
3757 fC[6][2] = 1.0000;
3758 fC[6][3] = 0.1480;
3759 fC[6][4] = 0.1058;
3760
3761 fC[7][0] = 0.005;
3762 fC[7][1] = 0.005;
3763 fC[7][2] = 1.0000;
3764 fC[7][3] = 0.1807;
3765 fC[7][4] = 0.1366;
3766
3767 fC[8][0] = 0.005;
3768 fC[8][1] = 0.005;
3769 fC[8][2] = 1.0000;
3770 fC[8][3] = 0.2219;
3771 fC[8][4] = 0.1891;
3772
3773 fC[9][0] = 0.005;
3774 fC[9][1] = 0.005;
3775 fC[9][2] = 1.0000;
3776 fC[9][3] = 0.2804;
3777 fC[9][4] = 0.2730;
3778
3779 fC[10][0] = 0.005;
3780 fC[10][1] = 0.005;
3781 fC[10][2] = 1.0000;
3782 fC[10][3] = 0.3283;
3783 fC[10][4] = 0.3660;
3784
3785 fC[11][0] = 0.005;
3786 fC[11][1] = 0.005;
3787 fC[11][2] = 1.0000;
3788 fC[11][3] = 0.3710;
3789 fC[11][4] = 0.4647;
3790
3791 fC[12][0] = 0.005;
3792 fC[12][1] = 0.005;
3793 fC[12][2] = 1.0000;
3794 fC[12][3] = 0.4093;
3795 fC[12][4] = 0.5566;
3796
3797 fC[13][0] = 0.005;
3798 fC[13][1] = 0.005;
3799 fC[13][2] = 1.0000;
3800 fC[13][3] = 0.4302;
3801 fC[13][4] = 0.6410;
3802
3803 fC[14][0] = 0.005;
3804 fC[14][1] = 0.005;
3805 fC[14][2] = 1.0000;
3806 fC[14][3] = 0.4649;
3807 fC[14][4] = 0.7055;
3808
3809 fC[15][0] = 0.005;
3810 fC[15][1] = 0.005;
3811 fC[15][2] = 1.0000;
3812 fC[15][3] = 0.4523;
3813 fC[15][4] = 0.7440;
3814
3815 fC[16][0] = 0.005;
3816 fC[16][1] = 0.005;
3817 fC[16][2] = 1.0000;
3818 fC[16][3] = 0.4591;
3819 fC[16][4] = 0.7799;
3820
3821 fC[17][0] = 0.005;
3822 fC[17][1] = 0.005;
3823 fC[17][2] = 1.0000;
3824 fC[17][3] = 0.4804;
3825 fC[17][4] = 0.8218;
3826 }
3827 // 20-30%
3828 else if(centrCur < 30){
3829 fC[0][0] = 0.005;
3830 fC[0][1] = 0.005;
3831 fC[0][2] = 1.0000;
3832 fC[0][3] = 0.0010;
3833 fC[0][4] = 0.0010;
3834
3835 fC[1][0] = 0.005;
3836 fC[1][1] = 0.005;
3837 fC[1][2] = 1.0000;
3838 fC[1][3] = 0.0102;
3839 fC[1][4] = 0.0064;
3840
3841 fC[2][0] = 0.005;
3842 fC[2][1] = 0.005;
3843 fC[2][2] = 1.0000;
3844 fC[2][3] = 0.0292;
3845 fC[2][4] = 0.0066;
3846
3847 fC[3][0] = 0.005;
3848 fC[3][1] = 0.005;
3849 fC[3][2] = 1.0000;
3850 fC[3][3] = 0.0597;
3851 fC[3][4] = 0.0296;
3852
3853 fC[4][0] = 0.005;
3854 fC[4][1] = 0.005;
3855 fC[4][2] = 1.0000;
3856 fC[4][3] = 0.0900;
3857 fC[4][4] = 0.0589;
3858
3859 fC[5][0] = 0.005;
3860 fC[5][1] = 0.005;
3861 fC[5][2] = 1.0000;
3862 fC[5][3] = 0.1199;
3863 fC[5][4] = 0.0859;
3864
3865 fC[6][0] = 0.005;
3866 fC[6][1] = 0.005;
3867 fC[6][2] = 1.0000;
3868 fC[6][3] = 0.1505;
3869 fC[6][4] = 0.1141;
3870
3871 fC[7][0] = 0.005;
3872 fC[7][1] = 0.005;
3873 fC[7][2] = 1.0000;
3874 fC[7][3] = 0.1805;
3875 fC[7][4] = 0.1454;
3876
3877 fC[8][0] = 0.005;
3878 fC[8][1] = 0.005;
3879 fC[8][2] = 1.0000;
3880 fC[8][3] = 0.2221;
3881 fC[8][4] = 0.2004;
3882
3883 fC[9][0] = 0.005;
3884 fC[9][1] = 0.005;
3885 fC[9][2] = 1.0000;
3886 fC[9][3] = 0.2796;
3887 fC[9][4] = 0.2838;
3888
3889 fC[10][0] = 0.005;
3890 fC[10][1] = 0.005;
3891 fC[10][2] = 1.0000;
3892 fC[10][3] = 0.3271;
3893 fC[10][4] = 0.3682;
3894
3895 fC[11][0] = 0.005;
3896 fC[11][1] = 0.005;
3897 fC[11][2] = 1.0000;
3898 fC[11][3] = 0.3648;
3899 fC[11][4] = 0.4509;
3900
3901 fC[12][0] = 0.005;
3902 fC[12][1] = 0.005;
3903 fC[12][2] = 1.0000;
3904 fC[12][3] = 0.3988;
3905 fC[12][4] = 0.5339;
3906
3907 fC[13][0] = 0.005;
3908 fC[13][1] = 0.005;
3909 fC[13][2] = 1.0000;
3910 fC[13][3] = 0.4315;
3911 fC[13][4] = 0.5995;
3912
3913 fC[14][0] = 0.005;
3914 fC[14][1] = 0.005;
3915 fC[14][2] = 1.0000;
3916 fC[14][3] = 0.4548;
3917 fC[14][4] = 0.6612;
3918
3919 fC[15][0] = 0.005;
3920 fC[15][1] = 0.005;
3921 fC[15][2] = 1.0000;
3922 fC[15][3] = 0.4744;
3923 fC[15][4] = 0.7060;
3924
3925 fC[16][0] = 0.005;
3926 fC[16][1] = 0.005;
3927 fC[16][2] = 1.0000;
3928 fC[16][3] = 0.4899;
3929 fC[16][4] = 0.7388;
3930
3931 fC[17][0] = 0.005;
3932 fC[17][1] = 0.005;
3933 fC[17][2] = 1.0000;
3934 fC[17][3] = 0.4411;
3935 fC[17][4] = 0.7293;
3936 }
3937 // 30-40%
3938 else if(centrCur < 40){
3939 fC[0][0] = 0.005;
3940 fC[0][1] = 0.005;
3941 fC[0][2] = 1.0000;
3942 fC[0][3] = 0.0010;
3943 fC[0][4] = 0.0010;
3944
3945 fC[1][0] = 0.005;
3946 fC[1][1] = 0.005;
3947 fC[1][2] = 1.0000;
3948 fC[1][3] = 0.0102;
3949 fC[1][4] = 0.0048;
3950
3951 fC[2][0] = 0.005;
3952 fC[2][1] = 0.005;
3953 fC[2][2] = 1.0000;
3954 fC[2][3] = 0.0306;
3955 fC[2][4] = 0.0079;
3956
3957 fC[3][0] = 0.005;
3958 fC[3][1] = 0.005;
3959 fC[3][2] = 1.0000;
3960 fC[3][3] = 0.0617;
3961 fC[3][4] = 0.0338;
3962
3963 fC[4][0] = 0.005;
3964 fC[4][1] = 0.005;
3965 fC[4][2] = 1.0000;
3966 fC[4][3] = 0.0920;
3967 fC[4][4] = 0.0652;
3968
3969 fC[5][0] = 0.005;
3970 fC[5][1] = 0.005;
3971 fC[5][2] = 1.0000;
3972 fC[5][3] = 0.1211;
3973 fC[5][4] = 0.0955;
3974
3975 fC[6][0] = 0.005;
3976 fC[6][1] = 0.005;
3977 fC[6][2] = 1.0000;
3978 fC[6][3] = 0.1496;
3979 fC[6][4] = 0.1242;
3980
3981 fC[7][0] = 0.005;
3982 fC[7][1] = 0.005;
3983 fC[7][2] = 1.0000;
3984 fC[7][3] = 0.1807;
3985 fC[7][4] = 0.1576;
3986
3987 fC[8][0] = 0.005;
3988 fC[8][1] = 0.005;
3989 fC[8][2] = 1.0000;
3990 fC[8][3] = 0.2195;
3991 fC[8][4] = 0.2097;
3992
3993 fC[9][0] = 0.005;
3994 fC[9][1] = 0.005;
3995 fC[9][2] = 1.0000;
3996 fC[9][3] = 0.2732;
3997 fC[9][4] = 0.2884;
3998
3999 fC[10][0] = 0.005;
4000 fC[10][1] = 0.005;
4001 fC[10][2] = 1.0000;
4002 fC[10][3] = 0.3204;
4003 fC[10][4] = 0.3679;
4004
4005 fC[11][0] = 0.005;
4006 fC[11][1] = 0.005;
4007 fC[11][2] = 1.0000;
4008 fC[11][3] = 0.3564;
4009 fC[11][4] = 0.4449;
4010
4011 fC[12][0] = 0.005;
4012 fC[12][1] = 0.005;
4013 fC[12][2] = 1.0000;
4014 fC[12][3] = 0.3791;
4015 fC[12][4] = 0.5052;
4016
4017 fC[13][0] = 0.005;
4018 fC[13][1] = 0.005;
4019 fC[13][2] = 1.0000;
4020 fC[13][3] = 0.4062;
4021 fC[13][4] = 0.5647;
4022
4023 fC[14][0] = 0.005;
4024 fC[14][1] = 0.005;
4025 fC[14][2] = 1.0000;
4026 fC[14][3] = 0.4234;
4027 fC[14][4] = 0.6203;
4028
4029 fC[15][0] = 0.005;
4030 fC[15][1] = 0.005;
4031 fC[15][2] = 1.0000;
4032 fC[15][3] = 0.4441;
4033 fC[15][4] = 0.6381;
4034
4035 fC[16][0] = 0.005;
4036 fC[16][1] = 0.005;
4037 fC[16][2] = 1.0000;
4038 fC[16][3] = 0.4629;
4039 fC[16][4] = 0.6496;
4040
4041 fC[17][0] = 0.005;
4042 fC[17][1] = 0.005;
4043 fC[17][2] = 1.0000;
4044 fC[17][3] = 0.4293;
4045 fC[17][4] = 0.6491;
4046 }
4047 // 40-50%
4048 else if(centrCur < 50){
4049 fC[0][0] = 0.005;
4050 fC[0][1] = 0.005;
4051 fC[0][2] = 1.0000;
4052 fC[0][3] = 0.0010;
4053 fC[0][4] = 0.0010;
4054
4055 fC[1][0] = 0.005;
4056 fC[1][1] = 0.005;
4057 fC[1][2] = 1.0000;
4058 fC[1][3] = 0.0093;
4059 fC[1][4] = 0.0057;
4060
4061 fC[2][0] = 0.005;
4062 fC[2][1] = 0.005;
4063 fC[2][2] = 1.0000;
4064 fC[2][3] = 0.0319;
4065 fC[2][4] = 0.0075;
4066
4067 fC[3][0] = 0.005;
4068 fC[3][1] = 0.005;
4069 fC[3][2] = 1.0000;
4070 fC[3][3] = 0.0639;
4071 fC[3][4] = 0.0371;
4072
4073 fC[4][0] = 0.005;
4074 fC[4][1] = 0.005;
4075 fC[4][2] = 1.0000;
4076 fC[4][3] = 0.0939;
4077 fC[4][4] = 0.0725;
4078
4079 fC[5][0] = 0.005;
4080 fC[5][1] = 0.005;
4081 fC[5][2] = 1.0000;
4082 fC[5][3] = 0.1224;
4083 fC[5][4] = 0.1045;
4084
4085 fC[6][0] = 0.005;
4086 fC[6][1] = 0.005;
4087 fC[6][2] = 1.0000;
4088 fC[6][3] = 0.1520;
4089 fC[6][4] = 0.1387;
4090
4091 fC[7][0] = 0.005;
4092 fC[7][1] = 0.005;
4093 fC[7][2] = 1.0000;
4094 fC[7][3] = 0.1783;
4095 fC[7][4] = 0.1711;
4096
4097 fC[8][0] = 0.005;
4098 fC[8][1] = 0.005;
4099 fC[8][2] = 1.0000;
4100 fC[8][3] = 0.2202;
4101 fC[8][4] = 0.2269;
4102
4103 fC[9][0] = 0.005;
4104 fC[9][1] = 0.005;
4105 fC[9][2] = 1.0000;
4106 fC[9][3] = 0.2672;
4107 fC[9][4] = 0.2955;
4108
4109 fC[10][0] = 0.005;
4110 fC[10][1] = 0.005;
4111 fC[10][2] = 1.0000;
4112 fC[10][3] = 0.3191;
4113 fC[10][4] = 0.3676;
4114
4115 fC[11][0] = 0.005;
4116 fC[11][1] = 0.005;
4117 fC[11][2] = 1.0000;
4118 fC[11][3] = 0.3434;
4119 fC[11][4] = 0.4321;
4120
4121 fC[12][0] = 0.005;
4122 fC[12][1] = 0.005;
4123 fC[12][2] = 1.0000;
4124 fC[12][3] = 0.3692;
4125 fC[12][4] = 0.4879;
4126
4127 fC[13][0] = 0.005;
4128 fC[13][1] = 0.005;
4129 fC[13][2] = 1.0000;
4130 fC[13][3] = 0.3993;
4131 fC[13][4] = 0.5377;
4132
4133 fC[14][0] = 0.005;
4134 fC[14][1] = 0.005;
4135 fC[14][2] = 1.0000;
4136 fC[14][3] = 0.3818;
4137 fC[14][4] = 0.5547;
4138
4139 fC[15][0] = 0.005;
4140 fC[15][1] = 0.005;
4141 fC[15][2] = 1.0000;
4142 fC[15][3] = 0.4003;
4143 fC[15][4] = 0.5484;
4144
4145 fC[16][0] = 0.005;
4146 fC[16][1] = 0.005;
4147 fC[16][2] = 1.0000;
4148 fC[16][3] = 0.4281;
4149 fC[16][4] = 0.5383;
4150
4151 fC[17][0] = 0.005;
4152 fC[17][1] = 0.005;
4153 fC[17][2] = 1.0000;
4154 fC[17][3] = 0.3960;
4155 fC[17][4] = 0.5374;
4156 }
4157 // 50-60%
4158 else if(centrCur < 60){
4159 fC[0][0] = 0.005;
4160 fC[0][1] = 0.005;
4161 fC[0][2] = 1.0000;
4162 fC[0][3] = 0.0010;
4163 fC[0][4] = 0.0010;
4164
4165 fC[1][0] = 0.005;
4166 fC[1][1] = 0.005;
4167 fC[1][2] = 1.0000;
4168 fC[1][3] = 0.0076;
4169 fC[1][4] = 0.0032;
4170
4171 fC[2][0] = 0.005;
4172 fC[2][1] = 0.005;
4173 fC[2][2] = 1.0000;
4174 fC[2][3] = 0.0329;
4175 fC[2][4] = 0.0085;
4176
4177 fC[3][0] = 0.005;
4178 fC[3][1] = 0.005;
4179 fC[3][2] = 1.0000;
4180 fC[3][3] = 0.0653;
4181 fC[3][4] = 0.0423;
4182
4183 fC[4][0] = 0.005;
4184 fC[4][1] = 0.005;
4185 fC[4][2] = 1.0000;
4186 fC[4][3] = 0.0923;
4187 fC[4][4] = 0.0813;
4188
4189 fC[5][0] = 0.005;
4190 fC[5][1] = 0.005;
4191 fC[5][2] = 1.0000;
4192 fC[5][3] = 0.1219;
4193 fC[5][4] = 0.1161;
4194
4195 fC[6][0] = 0.005;
4196 fC[6][1] = 0.005;
4197 fC[6][2] = 1.0000;
4198 fC[6][3] = 0.1519;
4199 fC[6][4] = 0.1520;
4200
4201 fC[7][0] = 0.005;
4202 fC[7][1] = 0.005;
4203 fC[7][2] = 1.0000;
4204 fC[7][3] = 0.1763;
4205 fC[7][4] = 0.1858;
4206
4207 fC[8][0] = 0.005;
4208 fC[8][1] = 0.005;
4209 fC[8][2] = 1.0000;
4210 fC[8][3] = 0.2178;
4211 fC[8][4] = 0.2385;
4212
4213 fC[9][0] = 0.005;
4214 fC[9][1] = 0.005;
4215 fC[9][2] = 1.0000;
4216 fC[9][3] = 0.2618;
4217 fC[9][4] = 0.3070;
4218
4219 fC[10][0] = 0.005;
4220 fC[10][1] = 0.005;
4221 fC[10][2] = 1.0000;
4222 fC[10][3] = 0.3067;
4223 fC[10][4] = 0.3625;
4224
4225 fC[11][0] = 0.005;
4226 fC[11][1] = 0.005;
4227 fC[11][2] = 1.0000;
4228 fC[11][3] = 0.3336;
4229 fC[11][4] = 0.4188;
4230
4231 fC[12][0] = 0.005;
4232 fC[12][1] = 0.005;
4233 fC[12][2] = 1.0000;
4234 fC[12][3] = 0.3706;
4235 fC[12][4] = 0.4511;
4236
4237 fC[13][0] = 0.005;
4238 fC[13][1] = 0.005;
4239 fC[13][2] = 1.0000;
4240 fC[13][3] = 0.3765;
4241 fC[13][4] = 0.4729;
4242
4243 fC[14][0] = 0.005;
4244 fC[14][1] = 0.005;
4245 fC[14][2] = 1.0000;
4246 fC[14][3] = 0.3942;
4247 fC[14][4] = 0.4855;
4248
4249 fC[15][0] = 0.005;
4250 fC[15][1] = 0.005;
4251 fC[15][2] = 1.0000;
4252 fC[15][3] = 0.4051;
4253 fC[15][4] = 0.4762;
4254
4255 fC[16][0] = 0.005;
4256 fC[16][1] = 0.005;
4257 fC[16][2] = 1.0000;
4258 fC[16][3] = 0.3843;
4259 fC[16][4] = 0.4763;
4260
4261 fC[17][0] = 0.005;
4262 fC[17][1] = 0.005;
4263 fC[17][2] = 1.0000;
4264 fC[17][3] = 0.4237;
4265 fC[17][4] = 0.4773;
4266 }
4267 // 60-70%
4268 else if(centrCur < 70){
4269 fC[0][0] = 0.005;
4270 fC[0][1] = 0.005;
4271 fC[0][2] = 1.0000;
4272 fC[0][3] = 0.0010;
4273 fC[0][4] = 0.0010;
4274
4275 fC[1][0] = 0.005;
4276 fC[1][1] = 0.005;
4277 fC[1][2] = 1.0000;
4278 fC[1][3] = 0.0071;
4279 fC[1][4] = 0.0012;
4280
4281 fC[2][0] = 0.005;
4282 fC[2][1] = 0.005;
4283 fC[2][2] = 1.0000;
4284 fC[2][3] = 0.0336;
4285 fC[2][4] = 0.0097;
4286
4287 fC[3][0] = 0.005;
4288 fC[3][1] = 0.005;
4289 fC[3][2] = 1.0000;
4290 fC[3][3] = 0.0662;
4291 fC[3][4] = 0.0460;
4292
4293 fC[4][0] = 0.005;
4294 fC[4][1] = 0.005;
4295 fC[4][2] = 1.0000;
4296 fC[4][3] = 0.0954;
4297 fC[4][4] = 0.0902;
4298
4299 fC[5][0] = 0.005;
4300 fC[5][1] = 0.005;
4301 fC[5][2] = 1.0000;
4302 fC[5][3] = 0.1181;
4303 fC[5][4] = 0.1306;
4304
4305 fC[6][0] = 0.005;
4306 fC[6][1] = 0.005;
4307 fC[6][2] = 1.0000;
4308 fC[6][3] = 0.1481;
4309 fC[6][4] = 0.1662;
4310
4311 fC[7][0] = 0.005;
4312 fC[7][1] = 0.005;
4313 fC[7][2] = 1.0000;
4314 fC[7][3] = 0.1765;
4315 fC[7][4] = 0.1963;
4316
4317 fC[8][0] = 0.005;
4318 fC[8][1] = 0.005;
4319 fC[8][2] = 1.0000;
4320 fC[8][3] = 0.2155;
4321 fC[8][4] = 0.2433;
4322
4323 fC[9][0] = 0.005;
4324 fC[9][1] = 0.005;
4325 fC[9][2] = 1.0000;
4326 fC[9][3] = 0.2580;
4327 fC[9][4] = 0.3022;
4328
4329 fC[10][0] = 0.005;
4330 fC[10][1] = 0.005;
4331 fC[10][2] = 1.0000;
4332 fC[10][3] = 0.2872;
4333 fC[10][4] = 0.3481;
4334
4335 fC[11][0] = 0.005;
4336 fC[11][1] = 0.005;
4337 fC[11][2] = 1.0000;
4338 fC[11][3] = 0.3170;
4339 fC[11][4] = 0.3847;
4340
4341 fC[12][0] = 0.005;
4342 fC[12][1] = 0.005;
4343 fC[12][2] = 1.0000;
4344 fC[12][3] = 0.3454;
4345 fC[12][4] = 0.4258;
4346
4347 fC[13][0] = 0.005;
4348 fC[13][1] = 0.005;
4349 fC[13][2] = 1.0000;
4350 fC[13][3] = 0.3580;
4351 fC[13][4] = 0.4299;
4352
4353 fC[14][0] = 0.005;
4354 fC[14][1] = 0.005;
4355 fC[14][2] = 1.0000;
4356 fC[14][3] = 0.3903;
4357 fC[14][4] = 0.4326;
4358
4359 fC[15][0] = 0.005;
4360 fC[15][1] = 0.005;
4361 fC[15][2] = 1.0000;
4362 fC[15][3] = 0.3690;
4363 fC[15][4] = 0.4491;
4364
4365 fC[16][0] = 0.005;
4366 fC[16][1] = 0.005;
4367 fC[16][2] = 1.0000;
4368 fC[16][3] = 0.4716;
4369 fC[16][4] = 0.4298;
4370
4371 fC[17][0] = 0.005;
4372 fC[17][1] = 0.005;
4373 fC[17][2] = 1.0000;
4374 fC[17][3] = 0.3875;
4375 fC[17][4] = 0.4083;
4376 }
4377 // 70-80%
4378 else if(centrCur < 80){
4379 fC[0][0] = 0.005;
4380 fC[0][1] = 0.005;
4381 fC[0][2] = 1.0000;
4382 fC[0][3] = 0.0010;
4383 fC[0][4] = 0.0010;
4384
4385 fC[1][0] = 0.005;
4386 fC[1][1] = 0.005;
4387 fC[1][2] = 1.0000;
4388 fC[1][3] = 0.0075;
4389 fC[1][4] = 0.0007;
4390
4391 fC[2][0] = 0.005;
4392 fC[2][1] = 0.005;
4393 fC[2][2] = 1.0000;
4394 fC[2][3] = 0.0313;
4395 fC[2][4] = 0.0124;
4396
4397 fC[3][0] = 0.005;
4398 fC[3][1] = 0.005;
4399 fC[3][2] = 1.0000;
4400 fC[3][3] = 0.0640;
4401 fC[3][4] = 0.0539;
4402
4403 fC[4][0] = 0.005;
4404 fC[4][1] = 0.005;
4405 fC[4][2] = 1.0000;
4406 fC[4][3] = 0.0923;
4407 fC[4][4] = 0.0992;
4408
4409 fC[5][0] = 0.005;
4410 fC[5][1] = 0.005;
4411 fC[5][2] = 1.0000;
4412 fC[5][3] = 0.1202;
4413 fC[5][4] = 0.1417;
4414
4415 fC[6][0] = 0.005;
4416 fC[6][1] = 0.005;
4417 fC[6][2] = 1.0000;
4418 fC[6][3] = 0.1413;
4419 fC[6][4] = 0.1729;
4420
4421 fC[7][0] = 0.005;
4422 fC[7][1] = 0.005;
4423 fC[7][2] = 1.0000;
4424 fC[7][3] = 0.1705;
4425 fC[7][4] = 0.1999;
4426
4427 fC[8][0] = 0.005;
4428 fC[8][1] = 0.005;
4429 fC[8][2] = 1.0000;
4430 fC[8][3] = 0.2103;
4431 fC[8][4] = 0.2472;
4432
4433 fC[9][0] = 0.005;
4434 fC[9][1] = 0.005;
4435 fC[9][2] = 1.0000;
4436 fC[9][3] = 0.2373;
4437 fC[9][4] = 0.2916;
4438
4439 fC[10][0] = 0.005;
4440 fC[10][1] = 0.005;
4441 fC[10][2] = 1.0000;
4442 fC[10][3] = 0.2824;
4443 fC[10][4] = 0.3323;
4444
4445 fC[11][0] = 0.005;
4446 fC[11][1] = 0.005;
4447 fC[11][2] = 1.0000;
4448 fC[11][3] = 0.3046;
4449 fC[11][4] = 0.3576;
4450
4451 fC[12][0] = 0.005;
4452 fC[12][1] = 0.005;
4453 fC[12][2] = 1.0000;
4454 fC[12][3] = 0.3585;
4455 fC[12][4] = 0.4003;
4456
4457 fC[13][0] = 0.005;
4458 fC[13][1] = 0.005;
4459 fC[13][2] = 1.0000;
4460 fC[13][3] = 0.3461;
4461 fC[13][4] = 0.3982;
4462
4463 fC[14][0] = 0.005;
4464 fC[14][1] = 0.005;
4465 fC[14][2] = 1.0000;
4466 fC[14][3] = 0.3362;
4467 fC[14][4] = 0.3776;
4468
4469 fC[15][0] = 0.005;
4470 fC[15][1] = 0.005;
4471 fC[15][2] = 1.0000;
4472 fC[15][3] = 0.3071;
4473 fC[15][4] = 0.3500;
4474
4475 fC[16][0] = 0.005;
4476 fC[16][1] = 0.005;
4477 fC[16][2] = 1.0000;
4478 fC[16][3] = 0.2914;
4479 fC[16][4] = 0.3937;
4480
4481 fC[17][0] = 0.005;
4482 fC[17][1] = 0.005;
4483 fC[17][2] = 1.0000;
4484 fC[17][3] = 0.3727;
4485 fC[17][4] = 0.3877;
4486 }
4487 // 80-100%
4488 else{
4489 fC[0][0] = 0.005;
4490 fC[0][1] = 0.005;
4491 fC[0][2] = 1.0000;
4492 fC[0][3] = 0.0010;
4493 fC[0][4] = 0.0010;
4494
4495 fC[1][0] = 0.005;
4496 fC[1][1] = 0.005;
4497 fC[1][2] = 1.0000;
4498 fC[1][3] = 0.0060;
4499 fC[1][4] = 0.0035;
4500
4501 fC[2][0] = 0.005;
4502 fC[2][1] = 0.005;
4503 fC[2][2] = 1.0000;
4504 fC[2][3] = 0.0323;
4505 fC[2][4] = 0.0113;
4506
4507 fC[3][0] = 0.005;
4508 fC[3][1] = 0.005;
4509 fC[3][2] = 1.0000;
4510 fC[3][3] = 0.0609;
4511 fC[3][4] = 0.0653;
4512
4513 fC[4][0] = 0.005;
4514 fC[4][1] = 0.005;
4515 fC[4][2] = 1.0000;
4516 fC[4][3] = 0.0922;
4517 fC[4][4] = 0.1076;
4518
4519 fC[5][0] = 0.005;
4520 fC[5][1] = 0.005;
4521 fC[5][2] = 1.0000;
4522 fC[5][3] = 0.1096;
4523 fC[5][4] = 0.1328;
4524
4525 fC[6][0] = 0.005;
4526 fC[6][1] = 0.005;
4527 fC[6][2] = 1.0000;
4528 fC[6][3] = 0.1495;
4529 fC[6][4] = 0.1779;
4530
4531 fC[7][0] = 0.005;
4532 fC[7][1] = 0.005;
4533 fC[7][2] = 1.0000;
4534 fC[7][3] = 0.1519;
4535 fC[7][4] = 0.1989;
4536
4537 fC[8][0] = 0.005;
4538 fC[8][1] = 0.005;
4539 fC[8][2] = 1.0000;
4540 fC[8][3] = 0.1817;
4541 fC[8][4] = 0.2472;
4542
4543 fC[9][0] = 0.005;
4544 fC[9][1] = 0.005;
4545 fC[9][2] = 1.0000;
4546 fC[9][3] = 0.2429;
4547 fC[9][4] = 0.2684;
4548
4549 fC[10][0] = 0.005;
4550 fC[10][1] = 0.005;
4551 fC[10][2] = 1.0000;
4552 fC[10][3] = 0.2760;
4553 fC[10][4] = 0.3098;
4554
4555 fC[11][0] = 0.005;
4556 fC[11][1] = 0.005;
4557 fC[11][2] = 1.0000;
4558 fC[11][3] = 0.2673;
4559 fC[11][4] = 0.3198;
4560
4561 fC[12][0] = 0.005;
4562 fC[12][1] = 0.005;
4563 fC[12][2] = 1.0000;
4564 fC[12][3] = 0.3165;
4565 fC[12][4] = 0.3564;
4566
4567 fC[13][0] = 0.005;
4568 fC[13][1] = 0.005;
4569 fC[13][2] = 1.0000;
4570 fC[13][3] = 0.3526;
4571 fC[13][4] = 0.3011;
4572
4573 fC[14][0] = 0.005;
4574 fC[14][1] = 0.005;
4575 fC[14][2] = 1.0000;
4576 fC[14][3] = 0.3788;
4577 fC[14][4] = 0.3011;
4578
4579 fC[15][0] = 0.005;
4580 fC[15][1] = 0.005;
4581 fC[15][2] = 1.0000;
4582 fC[15][3] = 0.3788;
4583 fC[15][4] = 0.3011;
4584
4585 fC[16][0] = 0.005;
4586 fC[16][1] = 0.005;
4587 fC[16][2] = 1.0000;
4588 fC[16][3] = 0.3788;
4589 fC[16][4] = 0.3011;
4590
4591 fC[17][0] = 0.005;
4592 fC[17][1] = 0.005;
4593 fC[17][2] = 1.0000;
4594 fC[17][3] = 0.3788;
4595 fC[17][4] = 0.3011;
4596 }
4597
4598 for(Int_t i=18;i<fgkPIDptBin;i++){
4599 fBinLimitPID[i] = 3.0 + 0.2 * (i-18);
4600 fC[i][0] = fC[17][0];
4601 fC[i][1] = fC[17][1];
4602 fC[i][2] = fC[17][2];
4603 fC[i][3] = fC[17][3];
4604 fC[i][4] = fC[17][4];
4605 }
4606}
4607
4608//---------------------------------------------------------------//
0d16f553 4609Bool_t AliFlowTrackCuts::TPCTOFagree(const AliVTrack *track)
875ee12a 4610{
3c67c769 4611 //check pid agreement between TPC and TOF
875ee12a 4612 Bool_t status = kFALSE;
0d16f553 4613
4614 const Float_t c = 2.99792457999999984e-02;
4615
875ee12a 4616 Float_t mass[5] = {5.10998909999999971e-04,1.05658000000000002e-01,1.39570000000000000e-01,4.93676999999999977e-01,9.38271999999999995e-01};
4617
4618
80efa607 4619 Double_t exptimes[9];
875ee12a 4620 track->GetIntegratedTimes(exptimes);
4621
4622 Float_t dedx = track->GetTPCsignal();
4623
4624 Float_t p = track->P();
4625 Float_t time = track->GetTOFsignal()- fESDpid.GetTOFResponse().GetStartTime(p);
0d16f553 4626 Float_t tl = exptimes[0]*c; // to work both for ESD and AOD
875ee12a 4627
4628 Float_t betagammares = fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[4], mass[4]);
4629
4630 Float_t betagamma1 = tl/(time-5 *betagammares) * 33.3564095198152043;
4631
4632// printf("betagamma1 = %f\n",betagamma1);
4633
4634 if(betagamma1 < 0.1) betagamma1 = 0.1;
4635
4636 if(betagamma1 < 0.99999) betagamma1 /= TMath::Sqrt(1-betagamma1*betagamma1);
4637 else betagamma1 = 100;
4638
4639 Float_t betagamma2 = tl/(time+5 *betagammares) * 33.3564095198152043;
4640// printf("betagamma2 = %f\n",betagamma2);
4641
4642 if(betagamma2 < 0.1) betagamma2 = 0.1;
4643
4644 if(betagamma2 < 0.99999) betagamma2 /= TMath::Sqrt(1-betagamma2*betagamma2);
4645 else betagamma2 = 100;
4646
4647
0d16f553 4648 Float_t momtpc=track->GetTPCmomentum();
875ee12a 4649
4650 for(Int_t i=0;i < 5;i++){
4651 Float_t resolutionTOF = fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[i], mass[i]);
4652 if(TMath::Abs(exptimes[i] - time) < 5 * resolutionTOF){
4653 Float_t dedxExp = 0;
4654 if(i==0) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kElectron);
4655 else if(i==1) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kMuon);
4656 else if(i==2) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kPion);
4657 else if(i==3) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kKaon);
4658 else if(i==4) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kProton);
4659
4660 Float_t resolutionTPC = 2;
4661 if(i==0) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kElectron);
4662 else if(i==1) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kMuon);
4663 else if(i==2) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kPion);
4664 else if(i==3) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kKaon);
4665 else if(i==4) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kProton);
4666
4667 if(TMath::Abs(dedx - dedxExp) < 3 * resolutionTPC){
4668 status = kTRUE;
4669 }
4670 }
4671 }
4672
4673 Float_t bb1 = fESDpid.GetTPCResponse().Bethe(betagamma1);
4674 Float_t bb2 = fESDpid.GetTPCResponse().Bethe(betagamma2);
4675 Float_t bbM = fESDpid.GetTPCResponse().Bethe((betagamma1+betagamma2)*0.5);
4676
4677
4678 // status = kFALSE;
4679 // for nuclei
4680 Float_t resolutionTOFpr = fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[4], mass[4]);
4681 Float_t resolutionTPCpr = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kProton);
4682 if(TMath::Abs(dedx-bb1) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){
4683 status = kTRUE;
4684 }
4685 else if(TMath::Abs(dedx-bb2) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){
4686 status = kTRUE;
4687 }
4688 else if(TMath::Abs(dedx-bbM) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){
4689 status = kTRUE;
4690 }
4691
4692 return status;
3abf7ecc 4693}
4694// end part added by F. Noferini
4695//-----------------------------------------------------------------------
2b1eaa10 4696
2b1eaa10 4697//-----------------------------------------------------------------------
4698const char* AliFlowTrackCuts::PIDsourceName(PIDsource s)
4699{
4700 //get the name of the particle id source
4701 switch (s)
4702 {
4703 case kTPCdedx:
4704 return "TPCdedx";
b9cf8f8e 4705 case kTPCbayesian:
4706 return "TPCbayesian";
2b1eaa10 4707 case kTOFbeta:
4708 return "TOFbeta";
4709 case kTPCpid:
4710 return "TPCpid";
4711 case kTOFpid:
4712 return "TOFpid";
4713 case kTOFbayesian:
4714 return "TOFbayesianPID";
1a80f9f6 4715 case kTOFbetaSimple:
4716 return "TOFbetaSimple";
8eca5d19 4717 case kTPCNuclei:
4718 return "TPCnuclei";
d0ce6147 4719 case kTPCTOFNsigma:
4720 return "TPCTOFNsigma";
2b1eaa10 4721 default:
4722 return "NOPID";
4723 }
4724}
4725
4726//-----------------------------------------------------------------------
4727const char* AliFlowTrackCuts::GetParamTypeName(trackParameterType type)
4728{
4729 //return the name of the selected parameter type
4730 switch (type)
4731 {
4732 case kMC:
4733 return "MC";
4734 case kGlobal:
1a80f9f6 4735 return "Global";
4736 case kTPCstandalone:
4737 return "TPCstandalone";
4738 case kSPDtracklet:
4739 return "SPDtracklets";
d148af7e 4740 case kPMD:
4741 return "PMD";
c27333c2
MK		 4742 case kVZERO:
4743 return "VZERO";
2e5052c5 4744 case kMUON: // XZhang 20120604
4745 return "MUON"; // XZhang 20120604
dd294bb6
MK		 4746 case kKink:
4747 return "Kink";
4748 case kV0:
4749 return "V0";
2b1eaa10 4750 default:
4751 return "unknown";
4752 }
4753}
4754
d148af7e 4755//-----------------------------------------------------------------------
3c67c769 4756Bool_t AliFlowTrackCuts::PassesPMDcuts(const AliESDPmdTrack* track )
d148af7e 4757{
4758 //check PMD specific cuts
4759 //clean up from last iteration, and init label
1a80f9f6 4760 Int_t det = track->GetDetector();
4761 //Int_t smn = track->GetSmn();
4762 Float_t clsX = track->GetClusterX();
4763 Float_t clsY = track->GetClusterY();
4764 Float_t clsZ = track->GetClusterZ();
4765 Float_t ncell = track->GetClusterCells();
4766 Float_t adc = track->GetClusterADC();
d148af7e 4767
4768 fTrack = NULL;
4769 fMCparticle=NULL;
2281e7c5 4770 fTrackLabel=-996;
d148af7e 4771
1a80f9f6 4772 fTrackEta = GetPmdEta(clsX,clsY,clsZ);
4773 fTrackPhi = GetPmdPhi(clsX,clsY);
d148af7e 4774 fTrackWeight = 1.0;
4775
4776 Bool_t pass=kTRUE;
4777 if (fCutEta) {if ( fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) pass = kFALSE;}
4778 if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) pass = kFALSE;}
1a80f9f6 4779 if (fCutPmdDet) {if(det != fPmdDet) pass = kFALSE;}
4780 if (fCutPmdAdc) {if(adc < fPmdAdc) pass = kFALSE;}
4781 if (fCutPmdNcell) {if(ncell < fPmdNcell) pass = kFALSE;}
d148af7e 4782
1a80f9f6 4783 return pass;
d148af7e 4784}
22289738 4785
4786//-----------------------------------------------------------------------
c27333c2 4787Bool_t AliFlowTrackCuts::PassesVZEROcuts(Int_t id)
22289738 4788{
c27333c2 4789 //check VZERO cuts
b35580e6 4790 if (id<0) return kFALSE;
4791
22289738 4792 //clean up from last iter
dd294bb6 4793 ClearTrack();
22289738 4794
1a80f9f6 4795 fTrackPhi = TMath::PiOver4()*(0.5+id%8);
647a09d3 4796
86a97121 4797 // 10102013 weighting vzero tiles - rbertens@cern.ch
c27333c2 4798 if(!fVZEROgainEqualization) {
86a97121 4799 // if for some reason the equalization is not initialized (e.g. 2011 data)
c27333c2 4800 // the fVZEROxpol[] weights are used to enable or disable vzero rings
54dd223b 4801 if(id<32) { // v0c side
86a97121 4802 fTrackEta = -3.45+0.5*(id/8);
c27333c2
MK		 4803 if(id < 8) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROCpol[0];
4804 else if (id < 16 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROCpol[1];
4805 else if (id < 24 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROCpol[2];
4806 else if (id < 32 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROCpol[3];
86a97121 4807 } else { // v0a side
4808 fTrackEta = +4.8-0.6*((id/8)-4);
c27333c2
MK		 4809 if( id < 40) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROApol[0];
4810 else if ( id < 48 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROApol[1];
4811 else if ( id < 56 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROApol[2];
4812 else if ( id < 64 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROApol[3];
86a97121 4813 }
4814 } else { // the equalization is initialized
4815 // note that disabled rings have already been excluded on calibration level in
c27333c2 4816 // AliFlowEvent (so for a disabled ring, fVZEROxpol is zero
86a97121 4817 if(id<32) { // v0c side
4818 fTrackEta = -3.45+0.5*(id/8);
c27333c2
MK		 4819 if(id < 8) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROCpol[0]/fVZEROgainEqualization->GetBinContent(1+id);
4820 else if (id < 16 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROCpol[1]/fVZEROgainEqualization->GetBinContent(1+id);
4821 else if (id < 24 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROCpol[2]/fVZEROgainEqualization->GetBinContent(1+id);
4822 else if (id < 32 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROCpol[3]/fVZEROgainEqualization->GetBinContent(1+id);
86a97121 4823 } else { // v0a side
4824 fTrackEta = +4.8-0.6*((id/8)-4);
c27333c2
MK		 4825 if( id < 40) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROApol[0]/fVZEROgainEqualization->GetBinContent(1+id);
4826 else if ( id < 48 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROApol[1]/fVZEROgainEqualization->GetBinContent(1+id);
4827 else if ( id < 56 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROApol[2]/fVZEROgainEqualization->GetBinContent(1+id);
4828 else if ( id < 64 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROApol[3]/fVZEROgainEqualization->GetBinContent(1+id);
86a97121 4829 }
4830 // printf ( " tile %i and weight %.2f \n", id, fTrackWeight);
4831 }
647a09d3 4832
1d78aabb 4833 if (fLinearizeVZEROresponse && id < 64)
92b507bb 4834 {
4835 //this is only needed in pass1 of LHC10h
c27333c2 4836 Float_t multVZERO[fgkNumberOfVZEROtracks];
92b507bb 4837 Float_t dummy=0.0;
cac040c5 4838 AliESDUtils::GetCorrV0((AliESDEvent*)fEvent,dummy,multVZERO);
c27333c2 4839 fTrackWeight = multVZERO[id];
92b507bb 4840 }
22289738 4841
4842 Bool_t pass=kTRUE;
4843 if (fCutEta) {if ( fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) pass = kFALSE;}
4844 if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) pass = kFALSE;}
4845
1a80f9f6 4846 return pass;
22289738 4847}
4848
2e5052c5 4849//-----------------------------------------------------------------------------
4850Bool_t AliFlowTrackCuts::PassesMuonCuts(AliVParticle* vparticle)
4851{
4852// XZhang 20120604
dd294bb6 4853 ClearTrack();
2e5052c5 4854 fTrackLabel = (fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel();
4855 if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
4856 else fMCparticle=NULL;
4857
4858 AliESDMuonTrack *esdTrack = dynamic_cast<AliESDMuonTrack*>(vparticle);
4859 AliAODTrack *aodTrack = dynamic_cast<AliAODTrack*>(vparticle);
4860 if ((!esdTrack) && (!aodTrack)) return kFALSE;
4861 if (!fMuonTrackCuts->IsSelected(vparticle)) return kFALSE;
4862 HandleVParticle(vparticle); if (!fTrack) return kFALSE;
4863 return kTRUE;
4864}
4865
1a80f9f6 4866//----------------------------------------------------------------------------//
4867Double_t AliFlowTrackCuts::GetPmdEta(Float_t xPos, Float_t yPos, Float_t zPos)
4868{
3c67c769 4869 //get PMD "track" eta coordinate
1a80f9f6 4870 Float_t rpxpy, theta, eta;
4871 rpxpy = TMath::Sqrt(xPos*xPos + yPos*yPos);
4872 theta = TMath::ATan2(rpxpy,zPos);
4873 eta = -TMath::Log(TMath::Tan(0.5*theta));
4874 return eta;
4875}
4876
4877//--------------------------------------------------------------------------//
4878Double_t AliFlowTrackCuts::GetPmdPhi(Float_t xPos, Float_t yPos)
4879{
3c67c769 4880 //Get PMD "track" phi coordinate
1a80f9f6 4881 Float_t pybypx, phi = 0., phi1;
4882 if(xPos==0)
4883 {
4884 if(yPos>0) phi = 90.;
4885 if(yPos<0) phi = 270.;
4886 }
4887 if(xPos != 0)
4888 {
4889 pybypx = yPos/xPos;
4890 if(pybypx < 0) pybypx = - pybypx;
4891 phi1 = TMath::ATan(pybypx)*180./3.14159;
4892
4893 if(xPos > 0 && yPos > 0) phi = phi1; // 1st Quadrant
4894 if(xPos < 0 && yPos > 0) phi = 180 - phi1; // 2nd Quadrant
4895 if(xPos < 0 && yPos < 0) phi = 180 + phi1; // 3rd Quadrant
4896 if(xPos > 0 && yPos < 0) phi = 360 - phi1; // 4th Quadrant
4897
4898 }
4899 phi = phi*3.14159/180.;
4900 return phi;
4901}
499fe731 4902
4903//---------------------------------------------------------------//
4904void AliFlowTrackCuts::Browse(TBrowser* b)
4905{
4906 //some browsing capabilities
4907 if (fQA) b->Add(fQA);
4908}
4909
1a80f9f6 4910//---------------------------------------------------------------//
499fe731 4911Long64_t AliFlowTrackCuts::Merge(TCollection* list)
4912{
4913 //merge
8eca5d19 4914 if (!fQA || !list) return 0;
4915 if (list->IsEmpty()) return 0;
4916 AliFlowTrackCuts* obj=NULL;
4917 TList tmplist;
499fe731 4918 TIter next(list);
4919 while ( (obj = dynamic_cast<AliFlowTrackCuts*>(next())) )
4920 {
4921 if (obj==this) continue;
8eca5d19 4922 tmplist.Add(obj->GetQA());
499fe731 4923 }
8eca5d19 4924 return fQA->Merge(&tmplist);
499fe731 4925}
f21bdf48 4926
9126fd0c 4927
2281e7c5 4928