]>
Commit | Line | Data |
---|---|---|
1 | /************************************************************************** | |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* $Id$ */ | |
17 | ||
18 | // AliFlowTrackCuts: | |
19 | // ESD track cuts for flow framework | |
20 | // | |
21 | // origin: Mikolaj Krzewicki (mikolaj.krzewicki@cern.ch) | |
22 | // | |
23 | // This class gurantees consistency of cut methods, trackparameter | |
24 | // selection (global tracks, TPC only, etc..) and parameter mixing | |
25 | // in the flow framework. Transparently handles different input types: | |
26 | // ESD, MC, AOD. | |
27 | // This class works in 2 steps: first the requested track parameters are | |
28 | // constructed (to be set by SetParamType() ), then cuts are applied. | |
29 | // the constructed track can be requested AFTER checking the cuts by | |
30 | // calling GetTrack(), in this case the cut object stays in control, | |
31 | // caller does not have to delete the track. | |
32 | // Additionally caller can request an AliFlowTrack object to be constructed | |
33 | // according the parameter mixing scenario requested by SetParamMix(). | |
34 | // AliFlowTrack is made using MakeFlowTrack() method, its an 'object factory' | |
35 | // so caller needs to take care of the freshly created object. | |
36 | ||
37 | #include <limits.h> | |
38 | #include <float.h> | |
39 | #include <TMatrix.h> | |
40 | #include "TMCProcess.h" | |
41 | #include "TParticle.h" | |
42 | #include "TH2F.h" | |
43 | #include "AliStack.h" | |
44 | #include "TBrowser.h" | |
45 | #include "AliMCEvent.h" | |
46 | #include "AliESDEvent.h" | |
47 | #include "AliVParticle.h" | |
48 | #include "AliMCParticle.h" | |
49 | #include "AliESDtrack.h" | |
50 | #include "AliMultiplicity.h" | |
51 | #include "AliAODTrack.h" | |
52 | #include "AliFlowTrack.h" | |
53 | #include "AliFlowTrackCuts.h" | |
54 | #include "AliLog.h" | |
55 | #include "AliESDpid.h" | |
56 | #include "AliESDPmdTrack.h" | |
57 | #include "AliESDVZERO.h" | |
58 | ||
59 | ClassImp(AliFlowTrackCuts) | |
60 | ||
61 | //----------------------------------------------------------------------- | |
62 | AliFlowTrackCuts::AliFlowTrackCuts(): | |
63 | AliFlowTrackSimpleCuts(), | |
64 | fAliESDtrackCuts(NULL), | |
65 | fQA(NULL), | |
66 | fCutMC(kFALSE), | |
67 | fCutMChasTrackReferences(kFALSE), | |
68 | fCutMCprocessType(kFALSE), | |
69 | fMCprocessType(kPNoProcess), | |
70 | fCutMCPID(kFALSE), | |
71 | fMCPID(0), | |
72 | fIgnoreSignInMCPID(kFALSE), | |
73 | fCutMCisPrimary(kFALSE), | |
74 | fRequireTransportBitForPrimaries(kTRUE), | |
75 | fMCisPrimary(kFALSE), | |
76 | fRequireCharge(kFALSE), | |
77 | fFakesAreOK(kTRUE), | |
78 | fCutSPDtrackletDeltaPhi(kFALSE), | |
79 | fSPDtrackletDeltaPhiMax(FLT_MAX), | |
80 | fSPDtrackletDeltaPhiMin(-FLT_MAX), | |
81 | fIgnoreTPCzRange(kFALSE), | |
82 | fIgnoreTPCzRangeMax(FLT_MAX), | |
83 | fIgnoreTPCzRangeMin(-FLT_MAX), | |
84 | fCutChi2PerClusterTPC(kFALSE), | |
85 | fMaxChi2PerClusterTPC(FLT_MAX), | |
86 | fMinChi2PerClusterTPC(-FLT_MAX), | |
87 | fCutNClustersTPC(kFALSE), | |
88 | fNClustersTPCMax(INT_MAX), | |
89 | fNClustersTPCMin(INT_MIN), | |
90 | fCutNClustersITS(kFALSE), | |
91 | fNClustersITSMax(INT_MAX), | |
92 | fNClustersITSMin(INT_MIN), | |
93 | fUseAODFilterBit(kFALSE), | |
94 | fAODFilterBit(0), | |
95 | fCutDCAToVertexXY(kFALSE), | |
96 | fCutDCAToVertexZ(kFALSE), | |
97 | fCutMinimalTPCdedx(kFALSE), | |
98 | fMinimalTPCdedx(0.), | |
99 | fCutPmdDet(kFALSE), | |
100 | fPmdDet(0), | |
101 | fCutPmdAdc(kFALSE), | |
102 | fPmdAdc(0.), | |
103 | fCutPmdNcell(kFALSE), | |
104 | fPmdNcell(0.), | |
105 | fParamType(kGlobal), | |
106 | fParamMix(kPure), | |
107 | fTrack(NULL), | |
108 | fTrackPhi(0.), | |
109 | fTrackEta(0.), | |
110 | fTrackWeight(0.), | |
111 | fTrackLabel(INT_MIN), | |
112 | fMCevent(NULL), | |
113 | fMCparticle(NULL), | |
114 | fEvent(NULL), | |
115 | fTPCtrack(), | |
116 | fESDpid(), | |
117 | fPIDsource(kTOFpid), | |
118 | fTPCpidCuts(NULL), | |
119 | fTOFpidCuts(NULL), | |
120 | fParticleID(AliPID::kUnknown), | |
121 | fParticleProbability(.9), | |
122 | fAllowTOFmismatchFlag(kFALSE), | |
123 | fRequireStrictTOFTPCagreement(kFALSE) | |
124 | { | |
125 | //io constructor | |
126 | for ( Int_t i=0; i<5; i++ ) { fProbBayes[i]=0.0; } | |
127 | SetPriors(); //init arrays | |
128 | } | |
129 | ||
130 | //----------------------------------------------------------------------- | |
131 | AliFlowTrackCuts::AliFlowTrackCuts(const char* name): | |
132 | AliFlowTrackSimpleCuts(), | |
133 | fAliESDtrackCuts(NULL), | |
134 | fQA(NULL), | |
135 | fCutMC(kFALSE), | |
136 | fCutMChasTrackReferences(kFALSE), | |
137 | fCutMCprocessType(kFALSE), | |
138 | fMCprocessType(kPNoProcess), | |
139 | fCutMCPID(kFALSE), | |
140 | fMCPID(0), | |
141 | fIgnoreSignInMCPID(kFALSE), | |
142 | fCutMCisPrimary(kFALSE), | |
143 | fRequireTransportBitForPrimaries(kTRUE), | |
144 | fMCisPrimary(kFALSE), | |
145 | fRequireCharge(kFALSE), | |
146 | fFakesAreOK(kTRUE), | |
147 | fCutSPDtrackletDeltaPhi(kFALSE), | |
148 | fSPDtrackletDeltaPhiMax(FLT_MAX), | |
149 | fSPDtrackletDeltaPhiMin(-FLT_MAX), | |
150 | fIgnoreTPCzRange(kFALSE), | |
151 | fIgnoreTPCzRangeMax(FLT_MAX), | |
152 | fIgnoreTPCzRangeMin(-FLT_MAX), | |
153 | fCutChi2PerClusterTPC(kFALSE), | |
154 | fMaxChi2PerClusterTPC(FLT_MAX), | |
155 | fMinChi2PerClusterTPC(-FLT_MAX), | |
156 | fCutNClustersTPC(kFALSE), | |
157 | fNClustersTPCMax(INT_MAX), | |
158 | fNClustersTPCMin(INT_MIN), | |
159 | fCutNClustersITS(kFALSE), | |
160 | fNClustersITSMax(INT_MAX), | |
161 | fNClustersITSMin(INT_MIN), | |
162 | fUseAODFilterBit(kFALSE), | |
163 | fAODFilterBit(0), | |
164 | fCutDCAToVertexXY(kFALSE), | |
165 | fCutDCAToVertexZ(kFALSE), | |
166 | fCutMinimalTPCdedx(kFALSE), | |
167 | fMinimalTPCdedx(0.), | |
168 | fCutPmdDet(kFALSE), | |
169 | fPmdDet(0), | |
170 | fCutPmdAdc(kFALSE), | |
171 | fPmdAdc(0.), | |
172 | fCutPmdNcell(kFALSE), | |
173 | fPmdNcell(0.), | |
174 | fParamType(kGlobal), | |
175 | fParamMix(kPure), | |
176 | fTrack(NULL), | |
177 | fTrackPhi(0.), | |
178 | fTrackEta(0.), | |
179 | fTrackWeight(0.), | |
180 | fTrackLabel(INT_MIN), | |
181 | fMCevent(NULL), | |
182 | fMCparticle(NULL), | |
183 | fEvent(NULL), | |
184 | fTPCtrack(), | |
185 | fESDpid(), | |
186 | fPIDsource(kTOFpid), | |
187 | fTPCpidCuts(NULL), | |
188 | fTOFpidCuts(NULL), | |
189 | fParticleID(AliPID::kUnknown), | |
190 | fParticleProbability(.9), | |
191 | fAllowTOFmismatchFlag(kFALSE), | |
192 | fRequireStrictTOFTPCagreement(kFALSE) | |
193 | { | |
194 | //constructor | |
195 | SetName(name); | |
196 | SetTitle("AliFlowTrackCuts"); | |
197 | fESDpid.GetTPCResponse().SetBetheBlochParameters( 0.0283086, | |
198 | 2.63394e+01, | |
199 | 5.04114e-11, | |
200 | 2.12543e+00, | |
201 | 4.88663e+00 ); | |
202 | for ( Int_t i=0; i<5; i++ ) { fProbBayes[i]=0.0; } | |
203 | SetPriors(); //init arrays | |
204 | ||
205 | } | |
206 | ||
207 | //----------------------------------------------------------------------- | |
208 | AliFlowTrackCuts::AliFlowTrackCuts(const AliFlowTrackCuts& that): | |
209 | AliFlowTrackSimpleCuts(that), | |
210 | fAliESDtrackCuts(NULL), | |
211 | fQA(NULL), | |
212 | fCutMC(that.fCutMC), | |
213 | fCutMChasTrackReferences(that.fCutMChasTrackReferences), | |
214 | fCutMCprocessType(that.fCutMCprocessType), | |
215 | fMCprocessType(that.fMCprocessType), | |
216 | fCutMCPID(that.fCutMCPID), | |
217 | fMCPID(that.fMCPID), | |
218 | fIgnoreSignInMCPID(that.fIgnoreSignInMCPID), | |
219 | fCutMCisPrimary(that.fCutMCisPrimary), | |
220 | fRequireTransportBitForPrimaries(that.fRequireTransportBitForPrimaries), | |
221 | fMCisPrimary(that.fMCisPrimary), | |
222 | fRequireCharge(that.fRequireCharge), | |
223 | fFakesAreOK(that.fFakesAreOK), | |
224 | fCutSPDtrackletDeltaPhi(that.fCutSPDtrackletDeltaPhi), | |
225 | fSPDtrackletDeltaPhiMax(that.fSPDtrackletDeltaPhiMax), | |
226 | fSPDtrackletDeltaPhiMin(that.fSPDtrackletDeltaPhiMin), | |
227 | fIgnoreTPCzRange(that.fIgnoreTPCzRange), | |
228 | fIgnoreTPCzRangeMax(that.fIgnoreTPCzRangeMax), | |
229 | fIgnoreTPCzRangeMin(that.fIgnoreTPCzRangeMin), | |
230 | fCutChi2PerClusterTPC(that.fCutChi2PerClusterTPC), | |
231 | fMaxChi2PerClusterTPC(that.fMaxChi2PerClusterTPC), | |
232 | fMinChi2PerClusterTPC(that.fMinChi2PerClusterTPC), | |
233 | fCutNClustersTPC(that.fCutNClustersTPC), | |
234 | fNClustersTPCMax(that.fNClustersTPCMax), | |
235 | fNClustersTPCMin(that.fNClustersTPCMin), | |
236 | fCutNClustersITS(that.fCutNClustersITS), | |
237 | fNClustersITSMax(that.fNClustersITSMax), | |
238 | fNClustersITSMin(that.fNClustersITSMin), | |
239 | fUseAODFilterBit(that.fUseAODFilterBit), | |
240 | fAODFilterBit(that.fAODFilterBit), | |
241 | fCutDCAToVertexXY(that.fCutDCAToVertexXY), | |
242 | fCutDCAToVertexZ(that.fCutDCAToVertexZ), | |
243 | fCutMinimalTPCdedx(that.fCutMinimalTPCdedx), | |
244 | fMinimalTPCdedx(that.fMinimalTPCdedx), | |
245 | fCutPmdDet(that.fCutPmdDet), | |
246 | fPmdDet(that.fPmdDet), | |
247 | fCutPmdAdc(that.fCutPmdAdc), | |
248 | fPmdAdc(that.fPmdAdc), | |
249 | fCutPmdNcell(that.fCutPmdNcell), | |
250 | fPmdNcell(that.fPmdNcell), | |
251 | fParamType(that.fParamType), | |
252 | fParamMix(that.fParamMix), | |
253 | fTrack(NULL), | |
254 | fTrackPhi(0.), | |
255 | fTrackEta(0.), | |
256 | fTrackWeight(0.), | |
257 | fTrackLabel(INT_MIN), | |
258 | fMCevent(NULL), | |
259 | fMCparticle(NULL), | |
260 | fEvent(NULL), | |
261 | fTPCtrack(), | |
262 | fESDpid(that.fESDpid), | |
263 | fPIDsource(that.fPIDsource), | |
264 | fTPCpidCuts(NULL), | |
265 | fTOFpidCuts(NULL), | |
266 | fParticleID(that.fParticleID), | |
267 | fParticleProbability(that.fParticleProbability), | |
268 | fAllowTOFmismatchFlag(that.fAllowTOFmismatchFlag), | |
269 | fRequireStrictTOFTPCagreement(that.fRequireStrictTOFTPCagreement) | |
270 | { | |
271 | //copy constructor | |
272 | if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts)); | |
273 | if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts)); | |
274 | if (that.fAliESDtrackCuts) fAliESDtrackCuts = new AliESDtrackCuts(*(that.fAliESDtrackCuts)); | |
275 | memcpy(fProbBayes,that.fProbBayes,sizeof(fProbBayes)); | |
276 | SetPriors(); //init arrays | |
277 | if (that.fQA) DefineHistograms(); | |
278 | } | |
279 | ||
280 | //----------------------------------------------------------------------- | |
281 | AliFlowTrackCuts& AliFlowTrackCuts::operator=(const AliFlowTrackCuts& that) | |
282 | { | |
283 | //assignment | |
284 | if (this==&that) return *this; | |
285 | ||
286 | AliFlowTrackSimpleCuts::operator=(that); | |
287 | //the following may seem excessive but if AliESDtrackCuts properly does copy and clone | |
288 | //this approach is better memory-fragmentation-wise in some cases | |
289 | if (that.fAliESDtrackCuts && fAliESDtrackCuts) *fAliESDtrackCuts=*(that.fAliESDtrackCuts); | |
290 | if (that.fAliESDtrackCuts && !fAliESDtrackCuts) fAliESDtrackCuts=new AliESDtrackCuts(*(that.fAliESDtrackCuts)); | |
291 | if (!that.fAliESDtrackCuts) delete fAliESDtrackCuts; fAliESDtrackCuts=NULL; | |
292 | //these guys we don't need to copy, just reinit | |
293 | if (that.fQA) {fQA->Delete(); delete fQA; fQA=NULL; DefineHistograms();} | |
294 | fCutMC=that.fCutMC; | |
295 | fCutMChasTrackReferences=that.fCutMChasTrackReferences; | |
296 | fCutMCprocessType=that.fCutMCprocessType; | |
297 | fMCprocessType=that.fMCprocessType; | |
298 | fCutMCPID=that.fCutMCPID; | |
299 | fMCPID=that.fMCPID; | |
300 | fIgnoreSignInMCPID=that.fIgnoreSignInMCPID, | |
301 | fCutMCisPrimary=that.fCutMCisPrimary; | |
302 | fRequireTransportBitForPrimaries=that.fRequireTransportBitForPrimaries; | |
303 | fMCisPrimary=that.fMCisPrimary; | |
304 | fRequireCharge=that.fRequireCharge; | |
305 | fFakesAreOK=that.fFakesAreOK; | |
306 | fCutSPDtrackletDeltaPhi=that.fCutSPDtrackletDeltaPhi; | |
307 | fSPDtrackletDeltaPhiMax=that.fSPDtrackletDeltaPhiMax; | |
308 | fSPDtrackletDeltaPhiMin=that.fSPDtrackletDeltaPhiMin; | |
309 | fIgnoreTPCzRange=that.fIgnoreTPCzRange; | |
310 | fIgnoreTPCzRangeMax=that.fIgnoreTPCzRangeMax; | |
311 | fIgnoreTPCzRangeMin=that.fIgnoreTPCzRangeMin; | |
312 | fCutChi2PerClusterTPC=that.fCutChi2PerClusterTPC; | |
313 | fMaxChi2PerClusterTPC=that.fMaxChi2PerClusterTPC; | |
314 | fMinChi2PerClusterTPC=that.fMinChi2PerClusterTPC; | |
315 | fCutNClustersTPC=that.fCutNClustersTPC; | |
316 | fNClustersTPCMax=that.fNClustersTPCMax; | |
317 | fNClustersTPCMin=that.fNClustersTPCMin; | |
318 | fCutNClustersITS=that.fCutNClustersITS; | |
319 | fNClustersITSMax=that.fNClustersITSMax; | |
320 | fNClustersITSMin=that.fNClustersITSMin; | |
321 | fUseAODFilterBit=that.fUseAODFilterBit; | |
322 | fAODFilterBit=that.fAODFilterBit; | |
323 | fCutDCAToVertexXY=that.fCutDCAToVertexXY; | |
324 | fCutDCAToVertexZ=that.fCutDCAToVertexZ; | |
325 | fCutMinimalTPCdedx=that.fCutMinimalTPCdedx; | |
326 | fMinimalTPCdedx=that.fMinimalTPCdedx; | |
327 | fCutPmdDet=that.fCutPmdDet; | |
328 | fPmdDet=that.fPmdDet; | |
329 | fCutPmdAdc=that.fCutPmdAdc; | |
330 | fPmdAdc=that.fPmdAdc; | |
331 | fCutPmdNcell=that.fCutPmdNcell; | |
332 | fPmdNcell=that.fPmdNcell; | |
333 | ||
334 | fParamType=that.fParamType; | |
335 | fParamMix=that.fParamMix; | |
336 | ||
337 | fTrack=NULL; | |
338 | fTrackEta=0.; | |
339 | fTrackPhi=0.; | |
340 | fTrackWeight=0.; | |
341 | fTrackLabel=INT_MIN; | |
342 | fMCevent=NULL; | |
343 | fMCparticle=NULL; | |
344 | fEvent=NULL; | |
345 | ||
346 | fESDpid = that.fESDpid; | |
347 | fPIDsource = that.fPIDsource; | |
348 | ||
349 | delete fTPCpidCuts; | |
350 | delete fTOFpidCuts; | |
351 | if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts)); | |
352 | if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts)); | |
353 | ||
354 | fParticleID=that.fParticleID; | |
355 | fParticleProbability=that.fParticleProbability; | |
356 | fAllowTOFmismatchFlag=that.fAllowTOFmismatchFlag; | |
357 | fRequireStrictTOFTPCagreement=that.fRequireStrictTOFTPCagreement; | |
358 | memcpy(fProbBayes,that.fProbBayes,sizeof(fProbBayes)); | |
359 | ||
360 | return *this; | |
361 | } | |
362 | ||
363 | //----------------------------------------------------------------------- | |
364 | AliFlowTrackCuts::~AliFlowTrackCuts() | |
365 | { | |
366 | //dtor | |
367 | delete fAliESDtrackCuts; | |
368 | delete fTPCpidCuts; | |
369 | delete fTOFpidCuts; | |
370 | if (fQA) { fQA->SetOwner(); fQA->Delete(); delete fQA; } | |
371 | } | |
372 | ||
373 | //----------------------------------------------------------------------- | |
374 | void AliFlowTrackCuts::SetEvent(AliVEvent* event, AliMCEvent* mcEvent) | |
375 | { | |
376 | //set the event | |
377 | Clear(); | |
378 | fEvent=event; | |
379 | fMCevent=mcEvent; | |
380 | ||
381 | //do the magic for ESD | |
382 | AliESDEvent* myESD = dynamic_cast<AliESDEvent*>(event); | |
383 | if (fCutPID && myESD) | |
384 | { | |
385 | //TODO: maybe call it only for the TOF options? | |
386 | // Added by F. Noferini for TOF PID | |
387 | fESDpid.SetTOFResponse(myESD,AliESDpid::kTOF_T0); | |
388 | fESDpid.MakePID(myESD,kFALSE); | |
389 | // End F. Noferini added part | |
390 | } | |
391 | ||
392 | //TODO: AOD | |
393 | } | |
394 | ||
395 | //----------------------------------------------------------------------- | |
396 | void AliFlowTrackCuts::SetCutMC( Bool_t b ) | |
397 | { | |
398 | //will we be cutting on MC information? | |
399 | fCutMC=b; | |
400 | ||
401 | //if we cut on MC info then also the Bethe Bloch should be the one tuned for MC | |
402 | if (fCutMC) | |
403 | { | |
404 | fESDpid.GetTPCResponse().SetBetheBlochParameters( 2.15898e+00/50., | |
405 | 1.75295e+01, | |
406 | 3.40030e-09, | |
407 | 1.96178e+00, | |
408 | 3.91720e+00); | |
409 | } | |
410 | } | |
411 | ||
412 | //----------------------------------------------------------------------- | |
413 | Bool_t AliFlowTrackCuts::IsSelected(TObject* obj, Int_t id) | |
414 | { | |
415 | //check cuts | |
416 | AliVParticle* vparticle = dynamic_cast<AliVParticle*>(obj); | |
417 | if (vparticle) return PassesCuts(vparticle); | |
418 | AliFlowTrackSimple* flowtrack = dynamic_cast<AliFlowTrackSimple*>(obj); | |
419 | if (flowtrack) return PassesCuts(flowtrack); | |
420 | AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj); | |
421 | if (tracklets) return PassesCuts(tracklets,id); | |
422 | AliESDPmdTrack* pmdtrack = dynamic_cast<AliESDPmdTrack*>(obj); | |
423 | if (pmdtrack) return PassesPMDcuts(pmdtrack); | |
424 | AliESDVZERO* esdvzero = dynamic_cast<AliESDVZERO*>(obj); | |
425 | if (esdvzero) return PassesV0cuts(esdvzero,id); | |
426 | return kFALSE; //default when passed wrong type of object | |
427 | } | |
428 | ||
429 | //----------------------------------------------------------------------- | |
430 | Bool_t AliFlowTrackCuts::IsSelectedMCtruth(TObject* obj, Int_t id) | |
431 | { | |
432 | //check cuts | |
433 | AliVParticle* vparticle = dynamic_cast<AliVParticle*>(obj); | |
434 | if (vparticle) | |
435 | { | |
436 | return PassesMCcuts(fMCevent,vparticle->GetLabel()); | |
437 | } | |
438 | AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj); | |
439 | if (tracklets) | |
440 | { | |
441 | Int_t label0 = tracklets->GetLabel(id,0); | |
442 | Int_t label1 = tracklets->GetLabel(id,1); | |
443 | Int_t label = (label0==label1)?tracklets->GetLabel(id,1):-666; | |
444 | return PassesMCcuts(fMCevent,label); | |
445 | } | |
446 | return kFALSE; //default when passed wrong type of object | |
447 | } | |
448 | ||
449 | //----------------------------------------------------------------------- | |
450 | Bool_t AliFlowTrackCuts::PassesCuts(const AliFlowTrackSimple* track) | |
451 | { | |
452 | //check cuts on a flowtracksimple | |
453 | ||
454 | //clean up from last iteration | |
455 | fTrack = NULL; | |
456 | return AliFlowTrackSimpleCuts::PassesCuts(track); | |
457 | } | |
458 | ||
459 | //----------------------------------------------------------------------- | |
460 | Bool_t AliFlowTrackCuts::PassesCuts(const AliMultiplicity* tracklet, Int_t id) | |
461 | { | |
462 | //check cuts on a tracklets | |
463 | ||
464 | //clean up from last iteration, and init label | |
465 | fTrack = NULL; | |
466 | fMCparticle=NULL; | |
467 | fTrackLabel=-1; | |
468 | ||
469 | fTrackPhi = tracklet->GetPhi(id); | |
470 | fTrackEta = tracklet->GetEta(id); | |
471 | fTrackWeight = 1.0; | |
472 | if (fCutEta) {if ( fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) return kFALSE;} | |
473 | if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) return kFALSE;} | |
474 | ||
475 | //check MC info if available | |
476 | //if the 2 clusters have different label track cannot be good | |
477 | //and should therefore not pass the mc cuts | |
478 | Int_t label0 = tracklet->GetLabel(id,0); | |
479 | Int_t label1 = tracklet->GetLabel(id,1); | |
480 | //if possible get label and mcparticle | |
481 | fTrackLabel = (label0==label1)?tracklet->GetLabel(id,1):-1; | |
482 | if (!fFakesAreOK && fTrackLabel<0) return kFALSE; | |
483 | if (fTrackLabel>=0 && fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel)); | |
484 | //check MC cuts | |
485 | if (fCutMC && !PassesMCcuts()) return kFALSE; | |
486 | return kTRUE; | |
487 | } | |
488 | ||
489 | //----------------------------------------------------------------------- | |
490 | Bool_t AliFlowTrackCuts::PassesMCcuts(AliMCEvent* mcEvent, Int_t label) | |
491 | { | |
492 | //check the MC info | |
493 | if (!mcEvent) return kFALSE; | |
494 | if (label<0) return kFALSE;//otherwise AliCMevent prints a warning before returning NULL | |
495 | AliMCParticle* mcparticle = static_cast<AliMCParticle*>(mcEvent->GetTrack(label)); | |
496 | if (!mcparticle) {AliError("no MC track"); return kFALSE;} | |
497 | ||
498 | if (fCutMCisPrimary) | |
499 | { | |
500 | if (IsPhysicalPrimary(mcEvent,label,fRequireTransportBitForPrimaries) != fMCisPrimary) return kFALSE; | |
501 | } | |
502 | if (fCutMCPID) | |
503 | { | |
504 | Int_t pdgCode = mcparticle->PdgCode(); | |
505 | if (fIgnoreSignInMCPID) | |
506 | { | |
507 | if (TMath::Abs(fMCPID) != TMath::Abs(pdgCode)) return kFALSE; | |
508 | } | |
509 | else | |
510 | { | |
511 | if (fMCPID != pdgCode) return kFALSE; | |
512 | } | |
513 | } | |
514 | if ( fCutMCprocessType ) | |
515 | { | |
516 | TParticle* particle = mcparticle->Particle(); | |
517 | Int_t processID = particle->GetUniqueID(); | |
518 | if (processID != fMCprocessType ) return kFALSE; | |
519 | } | |
520 | if (fCutMChasTrackReferences) | |
521 | { | |
522 | if (mcparticle->GetNumberOfTrackReferences()<1) return kFALSE; | |
523 | } | |
524 | return kTRUE; | |
525 | } | |
526 | ||
527 | //----------------------------------------------------------------------- | |
528 | Bool_t AliFlowTrackCuts::PassesMCcuts() | |
529 | { | |
530 | //check MC info | |
531 | if (!fMCevent) return kFALSE; | |
532 | if (fTrackLabel<0) return kFALSE;//otherwise AliCMevent prints a warning before returning NULL | |
533 | fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel)); | |
534 | return PassesMCcuts(fMCevent,fTrackLabel); | |
535 | } | |
536 | ||
537 | //----------------------------------------------------------------------- | |
538 | Bool_t AliFlowTrackCuts::PassesCuts(AliVParticle* vparticle) | |
539 | { | |
540 | //check cuts for an ESD vparticle | |
541 | ||
542 | //////////////////////////////////////////////////////////////// | |
543 | // start by preparing the track parameters to cut on ////////// | |
544 | //////////////////////////////////////////////////////////////// | |
545 | //clean up from last iteration | |
546 | fTrack=NULL; | |
547 | ||
548 | //get the label and the mc particle | |
549 | fTrackLabel = (fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel(); | |
550 | if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel)); | |
551 | else fMCparticle=NULL; | |
552 | ||
553 | Bool_t isMCparticle = kFALSE; //some things are different for MC particles, check! | |
554 | AliESDtrack* esdTrack = dynamic_cast<AliESDtrack*>(vparticle); | |
555 | AliAODTrack* aodTrack = NULL; | |
556 | if (esdTrack) | |
557 | { | |
558 | //for an ESD track we do some magic sometimes like constructing TPC only parameters | |
559 | //or doing some hybrid, handle that here | |
560 | HandleESDtrack(esdTrack); | |
561 | } | |
562 | else | |
563 | { | |
564 | HandleVParticle(vparticle); | |
565 | //now check if produced particle is MC | |
566 | isMCparticle = (dynamic_cast<AliMCParticle*>(fTrack))!=NULL; | |
567 | aodTrack = dynamic_cast<AliAODTrack*>(vparticle); //keep the additional dynamic cast out of the way for ESDs | |
568 | } | |
569 | //////////////////////////////////////////////////////////////// | |
570 | //////////////////////////////////////////////////////////////// | |
571 | ||
572 | if (!fTrack) return kFALSE; | |
573 | //because it may be different from global, not needed for aodTrack because we dont do anything funky there | |
574 | if (esdTrack) esdTrack = static_cast<AliESDtrack*>(fTrack); | |
575 | ||
576 | Bool_t pass=kTRUE; | |
577 | //check the common cuts for the current particle fTrack (MC,AOD,ESD) | |
578 | Double_t pt = fTrack->Pt(); | |
579 | Double_t p = fTrack->P(); | |
580 | if (!fFakesAreOK) {if (fTrackLabel<0) pass=kFALSE;} | |
581 | if (fCutPt) {if (pt < fPtMin || pt >= fPtMax ) pass=kFALSE;} | |
582 | if (fCutEta) {if (fTrack->Eta() < fEtaMin || fTrack->Eta() >= fEtaMax ) pass=kFALSE;} | |
583 | if (fCutPhi) {if (fTrack->Phi() < fPhiMin || fTrack->Phi() >= fPhiMax ) pass=kFALSE;} | |
584 | if (fRequireCharge) {if (fTrack->Charge() == 0) pass=kFALSE;} | |
585 | if (fCutCharge && !isMCparticle) {if (fTrack->Charge() != fCharge) pass=kFALSE;} | |
586 | if (fCutCharge && isMCparticle) | |
587 | { | |
588 | //in case of an MC particle the charge is stored in units of 1/3|e| | |
589 | Int_t charge = TMath::Nint(fTrack->Charge()/3.0); //mc particles have charge in units of 1/3e | |
590 | if (charge!=fCharge) pass=kFALSE; | |
591 | } | |
592 | //if(fCutPID) {if (fTrack->PID() != fPID) pass=kFALSE;} | |
593 | ||
594 | //when additionally MC info is required | |
595 | if (fCutMC && !PassesMCcuts()) pass=kFALSE; | |
596 | ||
597 | //the case of ESD or AOD | |
598 | if (esdTrack) { if (!PassesESDcuts(esdTrack)) { pass=kFALSE; } } | |
599 | if (aodTrack) { if (!PassesAODcuts(aodTrack)) { pass=kFALSE; } } | |
600 | ||
601 | if (fQA) | |
602 | { | |
603 | if (fMCparticle) | |
604 | { | |
605 | TParticle* tparticle=fMCparticle->Particle(); | |
606 | Int_t processID = tparticle->GetUniqueID(); | |
607 | //TLorentzVector v; | |
608 | //mcparticle->Particle()->ProductionVertex(v); | |
609 | //Double_t prodvtxX = v.X(); | |
610 | //Double_t prodvtxY = v.Y(); | |
611 | ||
612 | Float_t pdg = 0; | |
613 | Int_t pdgcode = fMCparticle->PdgCode(); | |
614 | switch (TMath::Abs(pdgcode)) | |
615 | { | |
616 | case 11: | |
617 | pdg = AliPID::kElectron + 0.5; break; | |
618 | case 13: | |
619 | pdg = AliPID::kMuon + 0.5; break; | |
620 | case 211: | |
621 | pdg = AliPID::kPion + 0.5; break; | |
622 | case 321: | |
623 | pdg = AliPID::kKaon + 0.5; break; | |
624 | case 2212: | |
625 | pdg = AliPID::kProton + 0.5; break; | |
626 | default: | |
627 | pdg = AliPID::kUnknown + 0.5; break; | |
628 | } | |
629 | pdg = TMath::Sign(pdg,static_cast<Float_t>(pdgcode)); | |
630 | QAbefore(2)->Fill(p,pdg); | |
631 | QAbefore(3)->Fill(p,IsPhysicalPrimary()?0.5:-0.5); | |
632 | QAbefore(4)->Fill(p,static_cast<Float_t>(processID)); | |
633 | if (pass) QAafter(2)->Fill(p,pdg); | |
634 | if (pass) QAafter(3)->Fill(p,IsPhysicalPrimary()?0.5:-0.5); | |
635 | if (pass) QAafter(4)->Fill(p,static_cast<Float_t>(processID)); | |
636 | } | |
637 | } | |
638 | ||
639 | //true by default, if we didn't set any cuts | |
640 | return pass; | |
641 | } | |
642 | ||
643 | //_______________________________________________________________________ | |
644 | Bool_t AliFlowTrackCuts::PassesAODcuts(const AliAODTrack* track) | |
645 | { | |
646 | //check cuts for AOD | |
647 | Bool_t pass = kTRUE; | |
648 | ||
649 | if (fCutNClustersTPC) | |
650 | { | |
651 | Int_t ntpccls = track->GetTPCNcls(); | |
652 | if (ntpccls < fNClustersTPCMin || ntpccls > fNClustersTPCMax) pass=kFALSE; | |
653 | } | |
654 | ||
655 | if (fCutNClustersITS) | |
656 | { | |
657 | Int_t nitscls = track->GetITSNcls(); | |
658 | if (nitscls < fNClustersITSMin || nitscls > fNClustersITSMax) pass=kFALSE; | |
659 | } | |
660 | ||
661 | if (fCutChi2PerClusterTPC) | |
662 | { | |
663 | Double_t chi2tpc = track->Chi2perNDF(); | |
664 | if (chi2tpc < fMinChi2PerClusterTPC || chi2tpc > fMaxChi2PerClusterTPC) pass=kFALSE; | |
665 | } | |
666 | ||
667 | if (GetRequireTPCRefit() && !(track->GetStatus() & AliESDtrack::kTPCrefit) ) pass=kFALSE; | |
668 | if (GetRequireITSRefit() && !(track->GetStatus() & AliESDtrack::kITSrefit) ) pass=kFALSE; | |
669 | ||
670 | if (fUseAODFilterBit && !track->TestFilterBit(fAODFilterBit)) pass=kFALSE; | |
671 | ||
672 | if (fCutDCAToVertexXY && track->DCA()>GetMaxDCAToVertexXY()) pass=kFALSE; | |
673 | ||
674 | ||
675 | return pass; | |
676 | } | |
677 | ||
678 | //_______________________________________________________________________ | |
679 | Bool_t AliFlowTrackCuts::PassesESDcuts(AliESDtrack* track) | |
680 | { | |
681 | //check cuts on ESD tracks | |
682 | Bool_t pass=kTRUE; | |
683 | const AliExternalTrackParam* pout = track->GetOuterParam(); | |
684 | const AliExternalTrackParam* pin = track->GetInnerParam(); | |
685 | if (fIgnoreTPCzRange) | |
686 | { | |
687 | if (pin&&pout) | |
688 | { | |
689 | Double_t zin = pin->GetZ(); | |
690 | Double_t zout = pout->GetZ(); | |
691 | if (zin*zout<0) pass=kFALSE; //reject if cross the membrane | |
692 | if (zin < fIgnoreTPCzRangeMin || zin > fIgnoreTPCzRangeMax) pass=kFALSE; | |
693 | if (zout < fIgnoreTPCzRangeMin || zout > fIgnoreTPCzRangeMax) pass=kFALSE; | |
694 | } | |
695 | } | |
696 | ||
697 | Int_t ntpccls = ( fParamType==kTPCstandalone )? | |
698 | track->GetTPCNclsIter1():track->GetTPCNcls(); | |
699 | if (fCutChi2PerClusterTPC) | |
700 | { | |
701 | Float_t tpcchi2 = (fParamType==kTPCstandalone)? | |
702 | track->GetTPCchi2Iter1():track->GetTPCchi2(); | |
703 | tpcchi2 = (ntpccls>0)?tpcchi2/ntpccls:-FLT_MAX; | |
704 | if (tpcchi2<fMinChi2PerClusterTPC || tpcchi2 >=fMaxChi2PerClusterTPC) | |
705 | pass=kFALSE; | |
706 | } | |
707 | ||
708 | if (fCutMinimalTPCdedx) | |
709 | { | |
710 | if (track->GetTPCsignal() < fMinimalTPCdedx) pass=kFALSE; | |
711 | } | |
712 | ||
713 | if (fCutNClustersTPC) | |
714 | { | |
715 | if (ntpccls < fNClustersTPCMin || ntpccls > fNClustersTPCMax) pass=kFALSE; | |
716 | } | |
717 | ||
718 | Int_t nitscls = track->GetNcls(0); | |
719 | if (fCutNClustersITS) | |
720 | { | |
721 | if (nitscls < fNClustersITSMin || nitscls > fNClustersITSMax) pass=kFALSE; | |
722 | } | |
723 | ||
724 | //some stuff is still handled by AliESDtrackCuts class - delegate | |
725 | if (fAliESDtrackCuts) | |
726 | { | |
727 | if (!fAliESDtrackCuts->IsSelected(track)) pass=kFALSE; | |
728 | } | |
729 | ||
730 | Double_t beta = GetBeta(track); | |
731 | Double_t dedx = Getdedx(track); | |
732 | if (fQA) | |
733 | { | |
734 | if (pass) QAbefore(0)->Fill(track->GetP(),beta); | |
735 | if (pass) QAbefore(1)->Fill(pin->GetP(),dedx); | |
736 | } | |
737 | if (fCutPID && (fParticleID!=AliPID::kUnknown)) //if kUnknown don't cut on PID | |
738 | { | |
739 | switch (fPIDsource) | |
740 | { | |
741 | case kTPCpid: | |
742 | if (!PassesTPCpidCut(track)) pass=kFALSE; | |
743 | break; | |
744 | case kTPCdedx: | |
745 | if (!PassesTPCdedxCut(track)) pass=kFALSE; | |
746 | break; | |
747 | case kTOFpid: | |
748 | if (!PassesTOFpidCut(track)) pass=kFALSE; | |
749 | break; | |
750 | case kTOFbeta: | |
751 | if (!PassesTOFbetaCut(track)) pass=kFALSE; | |
752 | break; | |
753 | case kTOFbetaSimple: | |
754 | if (!PassesTOFbetaSimpleCut(track)) pass=kFALSE; | |
755 | break; | |
756 | // part added by F. Noferini | |
757 | case kTOFbayesian: | |
758 | if (!PassesTOFbayesianCut(track)) pass=kFALSE; | |
759 | break; | |
760 | // end part added by F. Noferini | |
761 | default: | |
762 | printf("AliFlowTrackCuts::PassesCuts() this should never be called!\n"); | |
763 | pass=kFALSE; | |
764 | break; | |
765 | } | |
766 | } | |
767 | if (fQA) | |
768 | { | |
769 | if (pass) QAafter(0)->Fill(track->GetP(),beta); | |
770 | if (pass) QAafter(1)->Fill(pin->GetP(),dedx); | |
771 | } | |
772 | ||
773 | return pass; | |
774 | } | |
775 | ||
776 | //----------------------------------------------------------------------- | |
777 | void AliFlowTrackCuts::HandleVParticle(AliVParticle* track) | |
778 | { | |
779 | //handle the general case | |
780 | switch (fParamType) | |
781 | { | |
782 | default: | |
783 | fTrack = track; | |
784 | break; | |
785 | } | |
786 | } | |
787 | ||
788 | //----------------------------------------------------------------------- | |
789 | void AliFlowTrackCuts::HandleESDtrack(AliESDtrack* track) | |
790 | { | |
791 | //handle esd track | |
792 | switch (fParamType) | |
793 | { | |
794 | case kGlobal: | |
795 | fTrack = track; | |
796 | break; | |
797 | case kTPCstandalone: | |
798 | if (!track->FillTPCOnlyTrack(fTPCtrack)) | |
799 | { | |
800 | fTrack=NULL; | |
801 | fMCparticle=NULL; | |
802 | fTrackLabel=-1; | |
803 | return; | |
804 | } | |
805 | fTrack = &fTPCtrack; | |
806 | //recalculate the label and mc particle, they may differ as TPClabel != global label | |
807 | fTrackLabel = (fFakesAreOK)?TMath::Abs(fTrack->GetLabel()):fTrack->GetLabel(); | |
808 | if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel)); | |
809 | else fMCparticle=NULL; | |
810 | break; | |
811 | default: | |
812 | fTrack = track; | |
813 | break; | |
814 | } | |
815 | } | |
816 | ||
817 | //----------------------------------------------------------------------- | |
818 | Int_t AliFlowTrackCuts::Count(AliVEvent* event) | |
819 | { | |
820 | //calculate the number of track in given event. | |
821 | //if argument is NULL(default) take the event attached | |
822 | //by SetEvent() | |
823 | Int_t multiplicity = 0; | |
824 | if (!event) | |
825 | { | |
826 | for (Int_t i=0; i<GetNumberOfInputObjects(); i++) | |
827 | { | |
828 | if (IsSelected(GetInputObject(i))) multiplicity++; | |
829 | } | |
830 | } | |
831 | else | |
832 | { | |
833 | for (Int_t i=0; i<event->GetNumberOfTracks(); i++) | |
834 | { | |
835 | if (IsSelected(event->GetTrack(i))) multiplicity++; | |
836 | } | |
837 | } | |
838 | return multiplicity; | |
839 | } | |
840 | ||
841 | //----------------------------------------------------------------------- | |
842 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardVZEROOnlyTrackCuts() | |
843 | { | |
844 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard vzero flow cuts"); | |
845 | cuts->SetParamType(kV0); | |
846 | cuts->SetEtaRange( -10, +10 ); | |
847 | cuts->SetPhiMin( 0 ); | |
848 | cuts->SetPhiMax( TMath::TwoPi() ); | |
849 | return cuts; | |
850 | } | |
851 | ||
852 | //----------------------------------------------------------------------- | |
853 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardGlobalTrackCuts2010() | |
854 | { | |
855 | //get standard cuts | |
856 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard Global tracks"); | |
857 | cuts->SetParamType(kGlobal); | |
858 | cuts->SetPtRange(0.2,5.); | |
859 | cuts->SetEtaRange(-0.8,0.8); | |
860 | cuts->SetMinNClustersTPC(70); | |
861 | cuts->SetMinChi2PerClusterTPC(0.1); | |
862 | cuts->SetMaxChi2PerClusterTPC(4.0); | |
863 | cuts->SetMinNClustersITS(2); | |
864 | cuts->SetRequireITSRefit(kTRUE); | |
865 | cuts->SetRequireTPCRefit(kTRUE); | |
866 | cuts->SetMaxDCAToVertexXY(0.3); | |
867 | cuts->SetMaxDCAToVertexZ(0.3); | |
868 | cuts->SetAcceptKinkDaughters(kFALSE); | |
869 | cuts->SetMinimalTPCdedx(10.); | |
870 | ||
871 | return cuts; | |
872 | } | |
873 | ||
874 | //----------------------------------------------------------------------- | |
875 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010() | |
876 | { | |
877 | //get standard cuts | |
878 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard TPC standalone 2010"); | |
879 | cuts->SetParamType(kTPCstandalone); | |
880 | cuts->SetPtRange(0.2,5.); | |
881 | cuts->SetEtaRange(-0.8,0.8); | |
882 | cuts->SetMinNClustersTPC(70); | |
883 | cuts->SetMinChi2PerClusterTPC(0.2); | |
884 | cuts->SetMaxChi2PerClusterTPC(4.0); | |
885 | cuts->SetMaxDCAToVertexXY(3.0); | |
886 | cuts->SetMaxDCAToVertexZ(3.0); | |
887 | cuts->SetDCAToVertex2D(kTRUE); | |
888 | cuts->SetAcceptKinkDaughters(kFALSE); | |
889 | cuts->SetMinimalTPCdedx(10.); | |
890 | ||
891 | return cuts; | |
892 | } | |
893 | ||
894 | //----------------------------------------------------------------------- | |
895 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts() | |
896 | { | |
897 | //get standard cuts | |
898 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard TPC standalone"); | |
899 | cuts->SetParamType(kTPCstandalone); | |
900 | cuts->SetPtRange(0.2,5.); | |
901 | cuts->SetEtaRange(-0.8,0.8); | |
902 | cuts->SetMinNClustersTPC(70); | |
903 | cuts->SetMinChi2PerClusterTPC(0.2); | |
904 | cuts->SetMaxChi2PerClusterTPC(4.0); | |
905 | cuts->SetMaxDCAToVertexXY(3.0); | |
906 | cuts->SetMaxDCAToVertexZ(3.0); | |
907 | cuts->SetDCAToVertex2D(kTRUE); | |
908 | cuts->SetAcceptKinkDaughters(kFALSE); | |
909 | cuts->SetMinimalTPCdedx(10.); | |
910 | ||
911 | return cuts; | |
912 | } | |
913 | ||
914 | //----------------------------------------------------------------------- | |
915 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardITSTPCTrackCuts2009(Bool_t selPrimaries) | |
916 | { | |
917 | //get standard cuts | |
918 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard global track cuts 2009"); | |
919 | delete cuts->fAliESDtrackCuts; | |
920 | cuts->fAliESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selPrimaries); | |
921 | cuts->SetParamType(kGlobal); | |
922 | return cuts; | |
923 | } | |
924 | ||
925 | //----------------------------------------------------------------------- | |
926 | Bool_t AliFlowTrackCuts::FillFlowTrackGeneric(AliFlowTrack* flowtrack) const | |
927 | { | |
928 | //fill a flow track from tracklet,vzero,pmd,... | |
929 | TParticle *tmpTParticle=NULL; | |
930 | AliMCParticle* tmpAliMCParticle=NULL; | |
931 | switch (fParamMix) | |
932 | { | |
933 | case kPure: | |
934 | flowtrack->SetPhi(fTrackPhi); | |
935 | flowtrack->SetEta(fTrackEta); | |
936 | break; | |
937 | case kTrackWithMCkine: | |
938 | if (!fMCparticle) return kFALSE; | |
939 | flowtrack->SetPhi( fMCparticle->Phi() ); | |
940 | flowtrack->SetEta( fMCparticle->Eta() ); | |
941 | flowtrack->SetPt( fMCparticle->Pt() ); | |
942 | break; | |
943 | case kTrackWithMCpt: | |
944 | if (!fMCparticle) return kFALSE; | |
945 | flowtrack->SetPhi(fTrackPhi); | |
946 | flowtrack->SetEta(fTrackEta); | |
947 | flowtrack->SetPt(fMCparticle->Pt()); | |
948 | break; | |
949 | case kTrackWithPtFromFirstMother: | |
950 | if (!fMCparticle) return kFALSE; | |
951 | flowtrack->SetPhi(fTrackPhi); | |
952 | flowtrack->SetEta(fTrackEta); | |
953 | tmpTParticle = fMCparticle->Particle(); | |
954 | tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother())); | |
955 | flowtrack->SetPt(tmpAliMCParticle->Pt()); | |
956 | break; | |
957 | default: | |
958 | flowtrack->SetPhi(fTrackPhi); | |
959 | flowtrack->SetEta(fTrackEta); | |
960 | break; | |
961 | } | |
962 | flowtrack->SetSource(AliFlowTrack::kFromTracklet); | |
963 | return kTRUE; | |
964 | } | |
965 | ||
966 | //----------------------------------------------------------------------- | |
967 | Bool_t AliFlowTrackCuts::FillFlowTrackVParticle(AliFlowTrack* flowtrack) const | |
968 | { | |
969 | //fill flow track from AliVParticle (ESD,AOD,MC) | |
970 | if (!fTrack) return kFALSE; | |
971 | TParticle *tmpTParticle=NULL; | |
972 | AliMCParticle* tmpAliMCParticle=NULL; | |
973 | AliExternalTrackParam* externalParams=NULL; | |
974 | AliESDtrack* esdtrack=NULL; | |
975 | switch(fParamMix) | |
976 | { | |
977 | case kPure: | |
978 | flowtrack->Set(fTrack); | |
979 | break; | |
980 | case kTrackWithMCkine: | |
981 | flowtrack->Set(fMCparticle); | |
982 | break; | |
983 | case kTrackWithMCPID: | |
984 | flowtrack->Set(fTrack); | |
985 | //flowtrack->setPID(...) from mc, when implemented | |
986 | break; | |
987 | case kTrackWithMCpt: | |
988 | if (!fMCparticle) return kFALSE; | |
989 | flowtrack->Set(fTrack); | |
990 | flowtrack->SetPt(fMCparticle->Pt()); | |
991 | break; | |
992 | case kTrackWithPtFromFirstMother: | |
993 | if (!fMCparticle) return kFALSE; | |
994 | flowtrack->Set(fTrack); | |
995 | tmpTParticle = fMCparticle->Particle(); | |
996 | tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother())); | |
997 | flowtrack->SetPt(tmpAliMCParticle->Pt()); | |
998 | break; | |
999 | case kTrackWithTPCInnerParams: | |
1000 | esdtrack = dynamic_cast<AliESDtrack*>(fTrack); | |
1001 | if (!esdtrack) return kFALSE; | |
1002 | externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam()); | |
1003 | if (!externalParams) return kFALSE; | |
1004 | flowtrack->Set(externalParams); | |
1005 | break; | |
1006 | default: | |
1007 | flowtrack->Set(fTrack); | |
1008 | break; | |
1009 | } | |
1010 | if (fParamType==kMC) | |
1011 | { | |
1012 | flowtrack->SetSource(AliFlowTrack::kFromMC); | |
1013 | flowtrack->SetID(fTrack->GetLabel()); | |
1014 | } | |
1015 | else if (dynamic_cast<AliESDtrack*>(fTrack)) | |
1016 | { | |
1017 | flowtrack->SetSource(AliFlowTrack::kFromESD); | |
1018 | flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID()); | |
1019 | } | |
1020 | else if (dynamic_cast<AliAODTrack*>(fTrack)) | |
1021 | { | |
1022 | flowtrack->SetSource(AliFlowTrack::kFromAOD); | |
1023 | flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID()); | |
1024 | } | |
1025 | else if (dynamic_cast<AliMCParticle*>(fTrack)) | |
1026 | { | |
1027 | flowtrack->SetSource(AliFlowTrack::kFromMC); | |
1028 | flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID()); | |
1029 | } | |
1030 | return kTRUE; | |
1031 | } | |
1032 | ||
1033 | //----------------------------------------------------------------------- | |
1034 | Bool_t AliFlowTrackCuts::FillFlowTrack(AliFlowTrack* track) const | |
1035 | { | |
1036 | //fill a flow track constructed from whatever we applied cuts on | |
1037 | //return true on success | |
1038 | switch (fParamType) | |
1039 | { | |
1040 | case kSPDtracklet: | |
1041 | return FillFlowTrackGeneric(track); | |
1042 | case kPMD: | |
1043 | return FillFlowTrackGeneric(track); | |
1044 | case kV0: | |
1045 | return FillFlowTrackGeneric(track); | |
1046 | default: | |
1047 | return FillFlowTrackVParticle(track); | |
1048 | } | |
1049 | } | |
1050 | ||
1051 | //----------------------------------------------------------------------- | |
1052 | AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackSPDtracklet() const | |
1053 | { | |
1054 | //make a flow track from tracklet | |
1055 | AliFlowTrack* flowtrack=NULL; | |
1056 | TParticle *tmpTParticle=NULL; | |
1057 | AliMCParticle* tmpAliMCParticle=NULL; | |
1058 | switch (fParamMix) | |
1059 | { | |
1060 | case kPure: | |
1061 | flowtrack = new AliFlowTrack(); | |
1062 | flowtrack->SetPhi(fTrackPhi); | |
1063 | flowtrack->SetEta(fTrackEta); | |
1064 | break; | |
1065 | case kTrackWithMCkine: | |
1066 | if (!fMCparticle) return NULL; | |
1067 | flowtrack = new AliFlowTrack(); | |
1068 | flowtrack->SetPhi( fMCparticle->Phi() ); | |
1069 | flowtrack->SetEta( fMCparticle->Eta() ); | |
1070 | flowtrack->SetPt( fMCparticle->Pt() ); | |
1071 | break; | |
1072 | case kTrackWithMCpt: | |
1073 | if (!fMCparticle) return NULL; | |
1074 | flowtrack = new AliFlowTrack(); | |
1075 | flowtrack->SetPhi(fTrackPhi); | |
1076 | flowtrack->SetEta(fTrackEta); | |
1077 | flowtrack->SetPt(fMCparticle->Pt()); | |
1078 | break; | |
1079 | case kTrackWithPtFromFirstMother: | |
1080 | if (!fMCparticle) return NULL; | |
1081 | flowtrack = new AliFlowTrack(); | |
1082 | flowtrack->SetPhi(fTrackPhi); | |
1083 | flowtrack->SetEta(fTrackEta); | |
1084 | tmpTParticle = fMCparticle->Particle(); | |
1085 | tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother())); | |
1086 | flowtrack->SetPt(tmpAliMCParticle->Pt()); | |
1087 | break; | |
1088 | default: | |
1089 | flowtrack = new AliFlowTrack(); | |
1090 | flowtrack->SetPhi(fTrackPhi); | |
1091 | flowtrack->SetEta(fTrackEta); | |
1092 | break; | |
1093 | } | |
1094 | flowtrack->SetSource(AliFlowTrack::kFromTracklet); | |
1095 | return flowtrack; | |
1096 | } | |
1097 | ||
1098 | //----------------------------------------------------------------------- | |
1099 | AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackVParticle() const | |
1100 | { | |
1101 | //make flow track from AliVParticle (ESD,AOD,MC) | |
1102 | if (!fTrack) return NULL; | |
1103 | AliFlowTrack* flowtrack=NULL; | |
1104 | TParticle *tmpTParticle=NULL; | |
1105 | AliMCParticle* tmpAliMCParticle=NULL; | |
1106 | AliExternalTrackParam* externalParams=NULL; | |
1107 | AliESDtrack* esdtrack=NULL; | |
1108 | switch(fParamMix) | |
1109 | { | |
1110 | case kPure: | |
1111 | flowtrack = new AliFlowTrack(fTrack); | |
1112 | break; | |
1113 | case kTrackWithMCkine: | |
1114 | flowtrack = new AliFlowTrack(fMCparticle); | |
1115 | break; | |
1116 | case kTrackWithMCPID: | |
1117 | flowtrack = new AliFlowTrack(fTrack); | |
1118 | //flowtrack->setPID(...) from mc, when implemented | |
1119 | break; | |
1120 | case kTrackWithMCpt: | |
1121 | if (!fMCparticle) return NULL; | |
1122 | flowtrack = new AliFlowTrack(fTrack); | |
1123 | flowtrack->SetPt(fMCparticle->Pt()); | |
1124 | break; | |
1125 | case kTrackWithPtFromFirstMother: | |
1126 | if (!fMCparticle) return NULL; | |
1127 | flowtrack = new AliFlowTrack(fTrack); | |
1128 | tmpTParticle = fMCparticle->Particle(); | |
1129 | tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother())); | |
1130 | flowtrack->SetPt(tmpAliMCParticle->Pt()); | |
1131 | break; | |
1132 | case kTrackWithTPCInnerParams: | |
1133 | esdtrack = dynamic_cast<AliESDtrack*>(fTrack); | |
1134 | if (!esdtrack) return NULL; | |
1135 | externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam()); | |
1136 | if (!externalParams) return NULL; | |
1137 | flowtrack = new AliFlowTrack(externalParams); | |
1138 | break; | |
1139 | default: | |
1140 | flowtrack = new AliFlowTrack(fTrack); | |
1141 | break; | |
1142 | } | |
1143 | if (fParamType==kMC) | |
1144 | { | |
1145 | flowtrack->SetSource(AliFlowTrack::kFromMC); | |
1146 | flowtrack->SetID(fTrack->GetLabel()); | |
1147 | } | |
1148 | else if (dynamic_cast<AliESDtrack*>(fTrack)) | |
1149 | { | |
1150 | flowtrack->SetSource(AliFlowTrack::kFromESD); | |
1151 | flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID()); | |
1152 | } | |
1153 | else if (dynamic_cast<AliAODTrack*>(fTrack)) | |
1154 | { | |
1155 | flowtrack->SetSource(AliFlowTrack::kFromAOD); | |
1156 | flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID()); | |
1157 | } | |
1158 | else if (dynamic_cast<AliMCParticle*>(fTrack)) | |
1159 | { | |
1160 | flowtrack->SetSource(AliFlowTrack::kFromMC); | |
1161 | flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID()); | |
1162 | } | |
1163 | return flowtrack; | |
1164 | } | |
1165 | ||
1166 | //----------------------------------------------------------------------- | |
1167 | AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackPMDtrack() const | |
1168 | { | |
1169 | //make a flow track from PMD track | |
1170 | AliFlowTrack* flowtrack=NULL; | |
1171 | TParticle *tmpTParticle=NULL; | |
1172 | AliMCParticle* tmpAliMCParticle=NULL; | |
1173 | switch (fParamMix) | |
1174 | { | |
1175 | case kPure: | |
1176 | flowtrack = new AliFlowTrack(); | |
1177 | flowtrack->SetPhi(fTrackPhi); | |
1178 | flowtrack->SetEta(fTrackEta); | |
1179 | flowtrack->SetWeight(fTrackWeight); | |
1180 | break; | |
1181 | case kTrackWithMCkine: | |
1182 | if (!fMCparticle) return NULL; | |
1183 | flowtrack = new AliFlowTrack(); | |
1184 | flowtrack->SetPhi( fMCparticle->Phi() ); | |
1185 | flowtrack->SetEta( fMCparticle->Eta() ); | |
1186 | flowtrack->SetWeight(fTrackWeight); | |
1187 | flowtrack->SetPt( fMCparticle->Pt() ); | |
1188 | break; | |
1189 | case kTrackWithMCpt: | |
1190 | if (!fMCparticle) return NULL; | |
1191 | flowtrack = new AliFlowTrack(); | |
1192 | flowtrack->SetPhi(fTrackPhi); | |
1193 | flowtrack->SetEta(fTrackEta); | |
1194 | flowtrack->SetWeight(fTrackWeight); | |
1195 | flowtrack->SetPt(fMCparticle->Pt()); | |
1196 | break; | |
1197 | case kTrackWithPtFromFirstMother: | |
1198 | if (!fMCparticle) return NULL; | |
1199 | flowtrack = new AliFlowTrack(); | |
1200 | flowtrack->SetPhi(fTrackPhi); | |
1201 | flowtrack->SetEta(fTrackEta); | |
1202 | flowtrack->SetWeight(fTrackWeight); | |
1203 | tmpTParticle = fMCparticle->Particle(); | |
1204 | tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother())); | |
1205 | flowtrack->SetPt(tmpAliMCParticle->Pt()); | |
1206 | break; | |
1207 | default: | |
1208 | flowtrack = new AliFlowTrack(); | |
1209 | flowtrack->SetPhi(fTrackPhi); | |
1210 | flowtrack->SetEta(fTrackEta); | |
1211 | flowtrack->SetWeight(fTrackWeight); | |
1212 | break; | |
1213 | } | |
1214 | ||
1215 | flowtrack->SetSource(AliFlowTrack::kFromPMD); | |
1216 | return flowtrack; | |
1217 | } | |
1218 | ||
1219 | //----------------------------------------------------------------------- | |
1220 | AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackV0() const | |
1221 | { | |
1222 | //make a flow track from V0 | |
1223 | AliFlowTrack* flowtrack=NULL; | |
1224 | TParticle *tmpTParticle=NULL; | |
1225 | AliMCParticle* tmpAliMCParticle=NULL; | |
1226 | switch (fParamMix) | |
1227 | { | |
1228 | case kPure: | |
1229 | flowtrack = new AliFlowTrack(); | |
1230 | flowtrack->SetPhi(fTrackPhi); | |
1231 | flowtrack->SetEta(fTrackEta); | |
1232 | flowtrack->SetWeight(fTrackWeight); | |
1233 | break; | |
1234 | case kTrackWithMCkine: | |
1235 | if (!fMCparticle) return NULL; | |
1236 | flowtrack = new AliFlowTrack(); | |
1237 | flowtrack->SetPhi( fMCparticle->Phi() ); | |
1238 | flowtrack->SetEta( fMCparticle->Eta() ); | |
1239 | flowtrack->SetWeight(fTrackWeight); | |
1240 | flowtrack->SetPt( fMCparticle->Pt() ); | |
1241 | break; | |
1242 | case kTrackWithMCpt: | |
1243 | if (!fMCparticle) return NULL; | |
1244 | flowtrack = new AliFlowTrack(); | |
1245 | flowtrack->SetPhi(fTrackPhi); | |
1246 | flowtrack->SetEta(fTrackEta); | |
1247 | flowtrack->SetWeight(fTrackWeight); | |
1248 | flowtrack->SetPt(fMCparticle->Pt()); | |
1249 | break; | |
1250 | case kTrackWithPtFromFirstMother: | |
1251 | if (!fMCparticle) return NULL; | |
1252 | flowtrack = new AliFlowTrack(); | |
1253 | flowtrack->SetPhi(fTrackPhi); | |
1254 | flowtrack->SetEta(fTrackEta); | |
1255 | flowtrack->SetWeight(fTrackWeight); | |
1256 | tmpTParticle = fMCparticle->Particle(); | |
1257 | tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother())); | |
1258 | flowtrack->SetPt(tmpAliMCParticle->Pt()); | |
1259 | break; | |
1260 | default: | |
1261 | flowtrack = new AliFlowTrack(); | |
1262 | flowtrack->SetPhi(fTrackPhi); | |
1263 | flowtrack->SetEta(fTrackEta); | |
1264 | flowtrack->SetWeight(fTrackWeight); | |
1265 | break; | |
1266 | } | |
1267 | ||
1268 | flowtrack->SetSource(AliFlowTrack::kFromV0); | |
1269 | return flowtrack; | |
1270 | } | |
1271 | ||
1272 | //----------------------------------------------------------------------- | |
1273 | AliFlowTrack* AliFlowTrackCuts::MakeFlowTrack() const | |
1274 | { | |
1275 | //get a flow track constructed from whatever we applied cuts on | |
1276 | //caller is resposible for deletion | |
1277 | //if construction fails return NULL | |
1278 | //TODO: for tracklets, PMD and V0 we probably need just one method, | |
1279 | //something like MakeFlowTrackGeneric(), wait with this until | |
1280 | //requirements quirks are known. | |
1281 | switch (fParamType) | |
1282 | { | |
1283 | case kSPDtracklet: | |
1284 | return MakeFlowTrackSPDtracklet(); | |
1285 | case kPMD: | |
1286 | return MakeFlowTrackPMDtrack(); | |
1287 | case kV0: | |
1288 | return MakeFlowTrackV0(); | |
1289 | default: | |
1290 | return MakeFlowTrackVParticle(); | |
1291 | } | |
1292 | } | |
1293 | ||
1294 | //----------------------------------------------------------------------- | |
1295 | Bool_t AliFlowTrackCuts::IsPhysicalPrimary() const | |
1296 | { | |
1297 | //check if current particle is a physical primary | |
1298 | if (!fMCevent) return kFALSE; | |
1299 | if (fTrackLabel<0) return kFALSE; | |
1300 | return IsPhysicalPrimary(fMCevent, fTrackLabel, fRequireTransportBitForPrimaries); | |
1301 | } | |
1302 | ||
1303 | //----------------------------------------------------------------------- | |
1304 | Bool_t AliFlowTrackCuts::IsPhysicalPrimary(AliMCEvent* mcEvent, Int_t label, Bool_t requiretransported) | |
1305 | { | |
1306 | //check if current particle is a physical primary | |
1307 | Bool_t physprim=mcEvent->IsPhysicalPrimary(label); | |
1308 | AliMCParticle* track = static_cast<AliMCParticle*>(mcEvent->GetTrack(label)); | |
1309 | if (!track) return kFALSE; | |
1310 | TParticle* particle = track->Particle(); | |
1311 | Bool_t transported = particle->TestBit(kTransportBit); | |
1312 | //printf("label: %i prim: %s, transp: %s, pass: %s\n",label, (physprim)?"YES":"NO ",(transported)?"YES":"NO ", | |
1313 | //(physprim && (transported || !requiretransported))?"YES":"NO" ); | |
1314 | return (physprim && (transported || !requiretransported)); | |
1315 | } | |
1316 | ||
1317 | //----------------------------------------------------------------------- | |
1318 | void AliFlowTrackCuts::DefineHistograms() | |
1319 | { | |
1320 | //define qa histograms | |
1321 | if (fQA) return; | |
1322 | ||
1323 | Int_t kNbinsP=60; | |
1324 | Double_t binsP[kNbinsP+1]; | |
1325 | binsP[0]=0.0; | |
1326 | for(int i=1; i<=kNbinsP+1; i++) | |
1327 | { | |
1328 | if(binsP[i-1]+0.05<1.01) | |
1329 | binsP[i]=binsP[i-1]+0.05; | |
1330 | else | |
1331 | binsP[i]=binsP[i-1]+0.1; | |
1332 | } | |
1333 | ||
1334 | Bool_t adddirstatus = TH1::AddDirectoryStatus(); | |
1335 | TH1::AddDirectory(kFALSE); | |
1336 | fQA=new TList(); fQA->SetOwner(); | |
1337 | fQA->SetName(Form("%s QA",GetName())); | |
1338 | TList* before = new TList(); before->SetOwner(); | |
1339 | before->SetName("before"); | |
1340 | TList* after = new TList(); after->SetOwner(); | |
1341 | after->SetName("after"); | |
1342 | fQA->Add(before); | |
1343 | fQA->Add(after); | |
1344 | before->Add(new TH2F("TOFbeta",";p [GeV/c];#beta",kNbinsP,binsP,1000,0.4,1.1)); //0 | |
1345 | after->Add(new TH2F("TOFbeta",";p [GeV/c];#beta",kNbinsP,binsP,1000,0.4,1.1)); //0 | |
1346 | before->Add(new TH2F("TPCdedx",";p [GeV/c];dEdx",kNbinsP,binsP,500,0,500)); //1 | |
1347 | after->Add(new TH2F("TPCdedx",";p [GeV/c];dEdx",kNbinsP,binsP,500,0,500)); //1 | |
1348 | before->Add(new TH2F("MC pid",";p[GeV/c];species",kNbinsP,binsP,10,-5, 5)); //2 | |
1349 | after->Add(new TH2F("MC pid",";p[GeV/c];species",kNbinsP,binsP,10,-5, 5)); //2 | |
1350 | before->Add(new TH2F("MC primary",";p[GeV/c];primary",kNbinsP,binsP,2,-1,1)); //3 | |
1351 | after->Add(new TH2F("MC primary",";p[GeV/c];primary",kNbinsP,binsP,2,-1,1)); //3 | |
1352 | ||
1353 | //production process | |
1354 | TH2F* hb = new TH2F("MC production process",";p[GeV/c];",kNbinsP,binsP,kMaxMCProcess, | |
1355 | -0.5, kMaxMCProcess-0.5); | |
1356 | TH2F* ha = new TH2F("MC production process",";p[GeV/c];",kNbinsP,binsP,kMaxMCProcess, | |
1357 | -0.5, kMaxMCProcess-0.5); | |
1358 | TAxis* axis = hb->GetYaxis(); | |
1359 | for (Int_t i=0; i<kMaxMCProcess; i++) | |
1360 | { | |
1361 | axis->SetBinLabel(i+1,TMCProcessName[i]); | |
1362 | } | |
1363 | axis = hb->GetYaxis(); | |
1364 | for (Int_t i=0; i<kMaxMCProcess; i++) | |
1365 | { | |
1366 | axis->SetBinLabel(i+1,TMCProcessName[i]); | |
1367 | } | |
1368 | before->Add(hb); //4 | |
1369 | after->Add(ha); //4 | |
1370 | ||
1371 | TH1::AddDirectory(adddirstatus); | |
1372 | } | |
1373 | ||
1374 | //----------------------------------------------------------------------- | |
1375 | Int_t AliFlowTrackCuts::GetNumberOfInputObjects() const | |
1376 | { | |
1377 | //get the number of tracks in the input event according source | |
1378 | //selection (ESD tracks, tracklets, MC particles etc.) | |
1379 | AliESDEvent* esd=NULL; | |
1380 | switch (fParamType) | |
1381 | { | |
1382 | case kSPDtracklet: | |
1383 | esd = dynamic_cast<AliESDEvent*>(fEvent); | |
1384 | if (!esd) return 0; | |
1385 | return esd->GetMultiplicity()->GetNumberOfTracklets(); | |
1386 | case kMC: | |
1387 | if (!fMCevent) return 0; | |
1388 | return fMCevent->GetNumberOfTracks(); | |
1389 | case kPMD: | |
1390 | esd = dynamic_cast<AliESDEvent*>(fEvent); | |
1391 | if (!esd) return 0; | |
1392 | return esd->GetNumberOfPmdTracks(); | |
1393 | case kV0: | |
1394 | return fgkNumberOfV0tracks; | |
1395 | default: | |
1396 | if (!fEvent) return 0; | |
1397 | return fEvent->GetNumberOfTracks(); | |
1398 | } | |
1399 | return 0; | |
1400 | } | |
1401 | ||
1402 | //----------------------------------------------------------------------- | |
1403 | TObject* AliFlowTrackCuts::GetInputObject(Int_t i) | |
1404 | { | |
1405 | //get the input object according the data source selection: | |
1406 | //(esd tracks, traclets, mc particles,etc...) | |
1407 | AliESDEvent* esd=NULL; | |
1408 | switch (fParamType) | |
1409 | { | |
1410 | case kSPDtracklet: | |
1411 | esd = dynamic_cast<AliESDEvent*>(fEvent); | |
1412 | if (!esd) return NULL; | |
1413 | return const_cast<AliMultiplicity*>(esd->GetMultiplicity()); | |
1414 | case kMC: | |
1415 | if (!fMCevent) return NULL; | |
1416 | return fMCevent->GetTrack(i); | |
1417 | case kPMD: | |
1418 | esd = dynamic_cast<AliESDEvent*>(fEvent); | |
1419 | if (!esd) return NULL; | |
1420 | return esd->GetPmdTrack(i); | |
1421 | case kV0: | |
1422 | esd = dynamic_cast<AliESDEvent*>(fEvent); | |
1423 | if (!esd) return NULL; | |
1424 | return esd->GetVZEROData(); | |
1425 | default: | |
1426 | if (!fEvent) return NULL; | |
1427 | return fEvent->GetTrack(i); | |
1428 | } | |
1429 | } | |
1430 | ||
1431 | //----------------------------------------------------------------------- | |
1432 | void AliFlowTrackCuts::Clear(Option_t*) | |
1433 | { | |
1434 | //clean up | |
1435 | fTrack=NULL; | |
1436 | fMCevent=NULL; | |
1437 | fMCparticle=NULL; | |
1438 | fTrackLabel=-1; | |
1439 | fTrackWeight=0.0; | |
1440 | fTrackEta=0.0; | |
1441 | fTrackPhi=0.0; | |
1442 | } | |
1443 | ||
1444 | //----------------------------------------------------------------------- | |
1445 | Bool_t AliFlowTrackCuts::PassesTOFbetaSimpleCut(const AliESDtrack* track ) | |
1446 | { | |
1447 | //check if passes PID cut using timing in TOF | |
1448 | Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) && | |
1449 | (track->GetTOFsignal() > 12000) && | |
1450 | (track->GetTOFsignal() < 100000) && | |
1451 | (track->GetIntegratedLength() > 365); | |
1452 | ||
1453 | if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;} | |
1454 | ||
1455 | Bool_t statusMatchingHard = TPCTOFagree(track); | |
1456 | if (fRequireStrictTOFTPCagreement && (!statusMatchingHard)) | |
1457 | return kFALSE; | |
1458 | ||
1459 | if (!goodtrack) return kFALSE; | |
1460 | ||
1461 | const Float_t c = 2.99792457999999984e-02; | |
1462 | Float_t p = track->GetP(); | |
1463 | Float_t l = track->GetIntegratedLength(); | |
1464 | Float_t trackT0 = fESDpid.GetTOFResponse().GetStartTime(p); | |
1465 | Float_t timeTOF = track->GetTOFsignal()- trackT0; | |
1466 | Float_t beta = l/timeTOF/c; | |
1467 | Double_t integratedTimes[5] = {-1.0,-1.0,-1.0,-1.0,-1.0}; | |
1468 | track->GetIntegratedTimes(integratedTimes); | |
1469 | Float_t betaHypothesis[5] = {0.0,0.0,0.0,0.0,0.0}; | |
1470 | Float_t s[5] = {0.0,0.0,0.0,0.0,0.0}; | |
1471 | for (Int_t i=0;i<5;i++) | |
1472 | { | |
1473 | betaHypothesis[i] = l/integratedTimes[i]/c; | |
1474 | s[i] = beta-betaHypothesis[i]; | |
1475 | } | |
1476 | ||
1477 | switch (fParticleID) | |
1478 | { | |
1479 | case AliPID::kPion: | |
1480 | return ( (s[2]<0.015) && (s[2]>-0.015) && | |
1481 | (s[3]>0.025) && | |
1482 | (s[4]>0.03) ); | |
1483 | case AliPID::kKaon: | |
1484 | return ( (s[3]<0.015) && (s[3]>-0.015) && | |
1485 | (s[2]<-0.03) && | |
1486 | (s[4]>0.03) ); | |
1487 | case AliPID::kProton: | |
1488 | return ( (s[4]<0.015) && (s[4]>-0.015) && | |
1489 | (s[3]<-0.025) && | |
1490 | (s[2]<-0.025) ); | |
1491 | default: | |
1492 | return kFALSE; | |
1493 | } | |
1494 | return kFALSE; | |
1495 | } | |
1496 | ||
1497 | //----------------------------------------------------------------------- | |
1498 | Float_t AliFlowTrackCuts::GetBeta(const AliESDtrack* track) | |
1499 | { | |
1500 | //get beta | |
1501 | const Float_t c = 2.99792457999999984e-02; | |
1502 | Float_t p = track->GetP(); | |
1503 | Float_t l = track->GetIntegratedLength(); | |
1504 | Float_t trackT0 = fESDpid.GetTOFResponse().GetStartTime(p); | |
1505 | Float_t timeTOF = track->GetTOFsignal()- trackT0; | |
1506 | return l/timeTOF/c; | |
1507 | } | |
1508 | ||
1509 | //----------------------------------------------------------------------- | |
1510 | Bool_t AliFlowTrackCuts::PassesTOFbetaCut(const AliESDtrack* track ) | |
1511 | { | |
1512 | //check if passes PID cut using timing in TOF | |
1513 | Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) && | |
1514 | (track->GetTOFsignal() > 12000) && | |
1515 | (track->GetTOFsignal() < 100000) && | |
1516 | (track->GetIntegratedLength() > 365); | |
1517 | ||
1518 | if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;} | |
1519 | ||
1520 | Bool_t statusMatchingHard = TPCTOFagree(track); | |
1521 | if (fRequireStrictTOFTPCagreement && (!statusMatchingHard)) | |
1522 | return kFALSE; | |
1523 | ||
1524 | if (!goodtrack) return kFALSE; | |
1525 | ||
1526 | Float_t beta = GetBeta(track); | |
1527 | ||
1528 | Double_t integratedTimes[5] = {-1.0,-1.0,-1.0,-1.0,-1.0}; | |
1529 | track->GetIntegratedTimes(integratedTimes); | |
1530 | ||
1531 | //construct the pid index because it's not AliPID::EParticleType | |
1532 | Int_t pid = 0; | |
1533 | switch (fParticleID) | |
1534 | { | |
1535 | case AliPID::kPion: | |
1536 | pid=2; | |
1537 | break; | |
1538 | case AliPID::kKaon: | |
1539 | pid=3; | |
1540 | break; | |
1541 | case AliPID::kProton: | |
1542 | pid=4; | |
1543 | break; | |
1544 | default: | |
1545 | return kFALSE; | |
1546 | } | |
1547 | ||
1548 | //signal to cut on | |
1549 | const Float_t c = 2.99792457999999984e-02; | |
1550 | Float_t l = track->GetIntegratedLength(); | |
1551 | Float_t p = track->GetP(); | |
1552 | Float_t betahypothesis = l/integratedTimes[pid]/c; | |
1553 | Float_t betadiff = beta-betahypothesis; | |
1554 | ||
1555 | Float_t* arr = fTOFpidCuts->GetMatrixArray(); | |
1556 | Int_t col = TMath::BinarySearch(fTOFpidCuts->GetNcols(),arr,static_cast<Float_t>(p)); | |
1557 | if (col<0) return kFALSE; | |
1558 | Float_t min = (*fTOFpidCuts)(1,col); | |
1559 | Float_t max = (*fTOFpidCuts)(2,col); | |
1560 | ||
1561 | Bool_t pass = (betadiff>min && betadiff<max); | |
1562 | ||
1563 | return pass; | |
1564 | } | |
1565 | ||
1566 | //----------------------------------------------------------------------- | |
1567 | Bool_t AliFlowTrackCuts::PassesTOFpidCut(const AliESDtrack* track) const | |
1568 | { | |
1569 | //check if passes PID cut using default TOF pid | |
1570 | Double_t pidTOF[AliPID::kSPECIES]; | |
1571 | track->GetTOFpid(pidTOF); | |
1572 | if (pidTOF[fParticleID]>=fParticleProbability) return kTRUE; | |
1573 | return kFALSE; | |
1574 | } | |
1575 | ||
1576 | //----------------------------------------------------------------------- | |
1577 | Bool_t AliFlowTrackCuts::PassesTPCpidCut(const AliESDtrack* track) const | |
1578 | { | |
1579 | //check if passes PID cut using default TPC pid | |
1580 | Double_t pidTPC[AliPID::kSPECIES]; | |
1581 | track->GetTPCpid(pidTPC); | |
1582 | Double_t probablity = 0.; | |
1583 | switch (fParticleID) | |
1584 | { | |
1585 | case AliPID::kPion: | |
1586 | probablity = pidTPC[AliPID::kPion] + pidTPC[AliPID::kMuon]; | |
1587 | break; | |
1588 | default: | |
1589 | probablity = pidTPC[fParticleID]; | |
1590 | } | |
1591 | if (probablity >= fParticleProbability) return kTRUE; | |
1592 | return kFALSE; | |
1593 | } | |
1594 | ||
1595 | //----------------------------------------------------------------------- | |
1596 | Float_t AliFlowTrackCuts::Getdedx(const AliESDtrack* track) | |
1597 | { | |
1598 | //get TPC dedx | |
1599 | return track->GetTPCsignal(); | |
1600 | } | |
1601 | ||
1602 | //----------------------------------------------------------------------- | |
1603 | Bool_t AliFlowTrackCuts::PassesTPCdedxCut(const AliESDtrack* track) | |
1604 | { | |
1605 | //check if passes PID cut using dedx signal in the TPC | |
1606 | if (!fTPCpidCuts) | |
1607 | { | |
1608 | printf("no TPCpidCuts\n"); | |
1609 | return kFALSE; | |
1610 | } | |
1611 | ||
1612 | const AliExternalTrackParam* tpcparam = track->GetInnerParam(); //tpc only params at the inner wall | |
1613 | if (!tpcparam) return kFALSE; | |
1614 | Double_t p = tpcparam->GetP(); | |
1615 | Float_t sigExp = fESDpid.GetTPCResponse().GetExpectedSignal(p, fParticleID); | |
1616 | Float_t sigTPC = track->GetTPCsignal(); | |
1617 | Float_t s = (sigTPC-sigExp)/sigExp; | |
1618 | ||
1619 | Float_t* arr = fTPCpidCuts->GetMatrixArray(); | |
1620 | Int_t arrSize = fTPCpidCuts->GetNcols(); | |
1621 | Int_t col = TMath::BinarySearch( arrSize, arr, static_cast<Float_t>(p)); | |
1622 | if (col<0) return kFALSE; | |
1623 | Float_t min = (*fTPCpidCuts)(1,col); | |
1624 | Float_t max = (*fTPCpidCuts)(2,col); | |
1625 | ||
1626 | //printf("------------TPC pid cut %s\n",(s>min && s<max)?"PASS":"FAIL"); | |
1627 | return (s>min && s<max); | |
1628 | } | |
1629 | ||
1630 | //----------------------------------------------------------------------- | |
1631 | void AliFlowTrackCuts::InitPIDcuts() | |
1632 | { | |
1633 | //init matrices with PID cuts | |
1634 | TMatrixF* t = NULL; | |
1635 | if (!fTPCpidCuts) | |
1636 | { | |
1637 | if (fParticleID==AliPID::kPion) | |
1638 | { | |
1639 | t = new TMatrixF(3,15); | |
1640 | (*t)(0,0) = 0.20; (*t)(1,0) = -0.4; (*t)(2,0) = 0.0; | |
1641 | (*t)(0,1) = 0.25; (*t)(1,1) = -0.4; (*t)(2,1) = 0.1; | |
1642 | (*t)(0,2) = 0.30; (*t)(1,2) = -0.4; (*t)(2,2) = 0.2; | |
1643 | (*t)(0,3) = 0.35; (*t)(1,3) = -0.4; (*t)(2,3) = 0.2; | |
1644 | (*t)(0,4) = 0.40; (*t)(1,4) = -0.4; (*t)(2,4) = 0.3; | |
1645 | (*t)(0,5) = 0.45; (*t)(1,5) = -0.4; (*t)(2,5) = 0.3; | |
1646 | (*t)(0,6) = 0.50; (*t)(1,6) = -0.4; (*t)(2,6) = 0.25; | |
1647 | (*t)(0,7) = 0.55; (*t)(1,7) = -0.4; (*t)(2,7) = 0.15; | |
1648 | (*t)(0,8) = 0.60; (*t)(1,8) = -0.4; (*t)(2,8) = 0.1; | |
1649 | (*t)(0,9) = 0.65; (*t)(1,9) = -0.4; (*t)(2,9) = 0.05; | |
1650 | (*t)(0,10) = 0.70; (*t)(1,10) = -0.4; (*t)(2,10) = 0; | |
1651 | (*t)(0,11) = 0.75; (*t)(1,11) = -0.4; (*t)(2,11) = 0; | |
1652 | (*t)(0,12) = 0.80; (*t)(1,12) = -0.4; (*t)(2,12) = -0.05; | |
1653 | (*t)(0,13) = 0.85; (*t)(1,13) = -0.4; (*t)(2,13) = -0.1; | |
1654 | (*t)(0,14) = 0.90; (*t)(1,14) = 0; (*t)(2,14) = 0; | |
1655 | } | |
1656 | else | |
1657 | if (fParticleID==AliPID::kKaon) | |
1658 | { | |
1659 | t = new TMatrixF(3,12); | |
1660 | (*t)(0,0) = 0.20; (*t)(1,0) = -0.2; (*t)(2,0) = 0.2; | |
1661 | (*t)(0,1) = 0.25; (*t)(1,1) = -0.2; (*t)(2,1) = 0.2; | |
1662 | (*t)(0,2) = 0.30; (*t)(1,2) = -0.2; (*t)(2,2) = 0.2; | |
1663 | (*t)(0,3) = 0.35; (*t)(1,3) = -0.2; (*t)(2,3) = 0.2; | |
1664 | (*t)(0,4) = 0.40; (*t)(1,4) = -0.1; (*t)(2,4) = 0.2; | |
1665 | (*t)(0,5) = 0.45; (*t)(1,5) = -0.1; (*t)(2,5) = 0.2; | |
1666 | (*t)(0,6) = 0.50; (*t)(1,6) =-0.05; (*t)(2,6) = 0.2; | |
1667 | (*t)(0,7) = 0.55; (*t)(1,7) = -0.1; (*t)(2,7) = 0.1; | |
1668 | (*t)(0,8) = 0.60; (*t)(1,8) =-0.05; (*t)(2,8) = 0.1; | |
1669 | (*t)(0,9) = 0.65; (*t)(1,9) = 0; (*t)(2,9) = 0.15; | |
1670 | (*t)(0,10) = 0.70; (*t)(1,10) = 0.05; (*t)(2,10) = 0.2; | |
1671 | (*t)(0,11) = 0.75; (*t)(1,11) = 0; (*t)(2,11) = 0; | |
1672 | } | |
1673 | else | |
1674 | if (fParticleID==AliPID::kProton) | |
1675 | { | |
1676 | t = new TMatrixF(3,9); | |
1677 | (*t)(0,0) = 0.20; (*t)(1,0) = -0.1; (*t)(2,0) = 0.1; | |
1678 | (*t)(0,1) = 0.25; (*t)(1,1) = -0.2; (*t)(2,1) = 0.2; | |
1679 | (*t)(0,2) = 0.80; (*t)(1,2) = -0.1; (*t)(2,2) = 0.2; | |
1680 | (*t)(0,3) = 0.85; (*t)(1,3) =-0.05; (*t)(2,3) = 0.2; | |
1681 | (*t)(0,4) = 0.90; (*t)(1,4) =-0.05; (*t)(2,4) = 0.25; | |
1682 | (*t)(0,5) = 0.95; (*t)(1,5) =-0.05; (*t)(2,5) = 0.25; | |
1683 | (*t)(0,6) = 1.00; (*t)(1,6) = -0.1; (*t)(2,6) = 0.25; | |
1684 | (*t)(0,7) = 1.10; (*t)(1,7) =-0.05; (*t)(2,7) = 0.3; | |
1685 | (*t)(0,8) = 1.20; (*t)(1,8) = 0; (*t)(2,8) = 0; | |
1686 | } | |
1687 | delete fTPCpidCuts; | |
1688 | fTPCpidCuts=t; | |
1689 | } | |
1690 | t = NULL; | |
1691 | if (!fTOFpidCuts) | |
1692 | { | |
1693 | if (fParticleID==AliPID::kPion) | |
1694 | { | |
1695 | //TOF pions, 0.9 purity | |
1696 | t = new TMatrixF(3,61); | |
1697 | (*t)(0,0) = 0.000; (*t)(1,0) = 0.000; (*t)(2,0) = 0.000; | |
1698 | (*t)(0,1) = 0.050; (*t)(1,1) = 0.000; (*t)(2,1) = 0.000; | |
1699 | (*t)(0,2) = 0.100; (*t)(1,2) = 0.000; (*t)(2,2) = 0.000; | |
1700 | (*t)(0,3) = 0.150; (*t)(1,3) = 0.000; (*t)(2,3) = 0.000; | |
1701 | (*t)(0,4) = 0.200; (*t)(1,4) = -0.030; (*t)(2,4) = 0.030; | |
1702 | (*t)(0,5) = 0.250; (*t)(1,5) = -0.036; (*t)(2,5) = 0.032; | |
1703 | (*t)(0,6) = 0.300; (*t)(1,6) = -0.038; (*t)(2,6) = 0.032; | |
1704 | (*t)(0,7) = 0.350; (*t)(1,7) = -0.034; (*t)(2,7) = 0.032; | |
1705 | (*t)(0,8) = 0.400; (*t)(1,8) = -0.032; (*t)(2,8) = 0.020; | |
1706 | (*t)(0,9) = 0.450; (*t)(1,9) = -0.030; (*t)(2,9) = 0.020; | |
1707 | (*t)(0,10) = 0.500; (*t)(1,10) = -0.030; (*t)(2,10) = 0.020; | |
1708 | (*t)(0,11) = 0.550; (*t)(1,11) = -0.030; (*t)(2,11) = 0.020; | |
1709 | (*t)(0,12) = 0.600; (*t)(1,12) = -0.030; (*t)(2,12) = 0.020; | |
1710 | (*t)(0,13) = 0.650; (*t)(1,13) = -0.030; (*t)(2,13) = 0.020; | |
1711 | (*t)(0,14) = 0.700; (*t)(1,14) = -0.030; (*t)(2,14) = 0.020; | |
1712 | (*t)(0,15) = 0.750; (*t)(1,15) = -0.030; (*t)(2,15) = 0.020; | |
1713 | (*t)(0,16) = 0.800; (*t)(1,16) = -0.030; (*t)(2,16) = 0.020; | |
1714 | (*t)(0,17) = 0.850; (*t)(1,17) = -0.030; (*t)(2,17) = 0.020; | |
1715 | (*t)(0,18) = 0.900; (*t)(1,18) = -0.030; (*t)(2,18) = 0.020; | |
1716 | (*t)(0,19) = 0.950; (*t)(1,19) = -0.028; (*t)(2,19) = 0.028; | |
1717 | (*t)(0,20) = 1.000; (*t)(1,20) = -0.028; (*t)(2,20) = 0.028; | |
1718 | (*t)(0,21) = 1.100; (*t)(1,21) = -0.028; (*t)(2,21) = 0.028; | |
1719 | (*t)(0,22) = 1.200; (*t)(1,22) = -0.026; (*t)(2,22) = 0.028; | |
1720 | (*t)(0,23) = 1.300; (*t)(1,23) = -0.024; (*t)(2,23) = 0.028; | |
1721 | (*t)(0,24) = 1.400; (*t)(1,24) = -0.020; (*t)(2,24) = 0.028; | |
1722 | (*t)(0,25) = 1.500; (*t)(1,25) = -0.018; (*t)(2,25) = 0.028; | |
1723 | (*t)(0,26) = 1.600; (*t)(1,26) = -0.016; (*t)(2,26) = 0.028; | |
1724 | (*t)(0,27) = 1.700; (*t)(1,27) = -0.014; (*t)(2,27) = 0.028; | |
1725 | (*t)(0,28) = 1.800; (*t)(1,28) = -0.012; (*t)(2,28) = 0.026; | |
1726 | (*t)(0,29) = 1.900; (*t)(1,29) = -0.010; (*t)(2,29) = 0.026; | |
1727 | (*t)(0,30) = 2.000; (*t)(1,30) = -0.008; (*t)(2,30) = 0.026; | |
1728 | (*t)(0,31) = 2.100; (*t)(1,31) = -0.008; (*t)(2,31) = 0.024; | |
1729 | (*t)(0,32) = 2.200; (*t)(1,32) = -0.006; (*t)(2,32) = 0.024; | |
1730 | (*t)(0,33) = 2.300; (*t)(1,33) = -0.004; (*t)(2,33) = 0.024; | |
1731 | (*t)(0,34) = 2.400; (*t)(1,34) = -0.004; (*t)(2,34) = 0.024; | |
1732 | (*t)(0,35) = 2.500; (*t)(1,35) = -0.002; (*t)(2,35) = 0.024; | |
1733 | (*t)(0,36) = 2.600; (*t)(1,36) = -0.002; (*t)(2,36) = 0.024; | |
1734 | (*t)(0,37) = 2.700; (*t)(1,37) = 0.000; (*t)(2,37) = 0.024; | |
1735 | (*t)(0,38) = 2.800; (*t)(1,38) = 0.000; (*t)(2,38) = 0.026; | |
1736 | (*t)(0,39) = 2.900; (*t)(1,39) = 0.000; (*t)(2,39) = 0.024; | |
1737 | (*t)(0,40) = 3.000; (*t)(1,40) = 0.002; (*t)(2,40) = 0.026; | |
1738 | (*t)(0,41) = 3.100; (*t)(1,41) = 0.002; (*t)(2,41) = 0.026; | |
1739 | (*t)(0,42) = 3.200; (*t)(1,42) = 0.002; (*t)(2,42) = 0.026; | |
1740 | (*t)(0,43) = 3.300; (*t)(1,43) = 0.002; (*t)(2,43) = 0.026; | |
1741 | (*t)(0,44) = 3.400; (*t)(1,44) = 0.002; (*t)(2,44) = 0.026; | |
1742 | (*t)(0,45) = 3.500; (*t)(1,45) = 0.002; (*t)(2,45) = 0.026; | |
1743 | (*t)(0,46) = 3.600; (*t)(1,46) = 0.002; (*t)(2,46) = 0.026; | |
1744 | (*t)(0,47) = 3.700; (*t)(1,47) = 0.002; (*t)(2,47) = 0.026; | |
1745 | (*t)(0,48) = 3.800; (*t)(1,48) = 0.002; (*t)(2,48) = 0.026; | |
1746 | (*t)(0,49) = 3.900; (*t)(1,49) = 0.004; (*t)(2,49) = 0.024; | |
1747 | (*t)(0,50) = 4.000; (*t)(1,50) = 0.004; (*t)(2,50) = 0.026; | |
1748 | (*t)(0,51) = 4.100; (*t)(1,51) = 0.004; (*t)(2,51) = 0.026; | |
1749 | (*t)(0,52) = 4.200; (*t)(1,52) = 0.004; (*t)(2,52) = 0.024; | |
1750 | (*t)(0,53) = 4.300; (*t)(1,53) = 0.006; (*t)(2,53) = 0.024; | |
1751 | (*t)(0,54) = 4.400; (*t)(1,54) = 0.000; (*t)(2,54) = 0.000; | |
1752 | (*t)(0,55) = 4.500; (*t)(1,55) = 0.000; (*t)(2,55) = 0.000; | |
1753 | (*t)(0,56) = 4.600; (*t)(1,56) = 0.000; (*t)(2,56) = 0.000; | |
1754 | (*t)(0,57) = 4.700; (*t)(1,57) = 0.000; (*t)(2,57) = 0.000; | |
1755 | (*t)(0,58) = 4.800; (*t)(1,58) = 0.000; (*t)(2,58) = 0.000; | |
1756 | (*t)(0,59) = 4.900; (*t)(1,59) = 0.000; (*t)(2,59) = 0.000; | |
1757 | (*t)(0,60) = 5.900; (*t)(1,60) = 0.000; (*t)(2,60) = 0.000; | |
1758 | } | |
1759 | else | |
1760 | if (fParticleID==AliPID::kProton) | |
1761 | { | |
1762 | //TOF protons, 0.9 purity | |
1763 | t = new TMatrixF(3,61); | |
1764 | (*t)(0,0) = 0.000; (*t)(1,0) = 0.000; (*t)(2,0) = 0.000; | |
1765 | (*t)(0,1) = 0.050; (*t)(1,1) = 0.000; (*t)(2,1) = 0.000; | |
1766 | (*t)(0,2) = 0.100; (*t)(1,2) = 0.000; (*t)(2,2) = 0.000; | |
1767 | (*t)(0,3) = 0.150; (*t)(1,3) = 0.000; (*t)(2,3) = 0.000; | |
1768 | (*t)(0,4) = 0.200; (*t)(1,4) = -0.07; (*t)(2,4) = 0.07; | |
1769 | (*t)(0,5) = 0.200; (*t)(1,5) = -0.07; (*t)(2,5) = 0.07; | |
1770 | (*t)(0,6) = 0.200; (*t)(1,6) = -0.07; (*t)(2,6) = 0.07; | |
1771 | (*t)(0,7) = 0.200; (*t)(1,7) = -0.07; (*t)(2,7) = 0.07; | |
1772 | (*t)(0,8) = 0.200; (*t)(1,8) = -0.07; (*t)(2,8) = 0.07; | |
1773 | (*t)(0,9) = 0.200; (*t)(1,9) = -0.07; (*t)(2,9) = 0.07; | |
1774 | (*t)(0,10) = 0.200; (*t)(1,10) = -0.07; (*t)(2,10) = 0.07; | |
1775 | (*t)(0,11) = 0.200; (*t)(1,11) = -0.07; (*t)(2,11) = 0.07; | |
1776 | (*t)(0,12) = 0.200; (*t)(1,12) = -0.07; (*t)(2,12) = 0.07; | |
1777 | (*t)(0,13) = 0.200; (*t)(1,13) = -0.07; (*t)(2,13) = 0.07; | |
1778 | (*t)(0,14) = 0.200; (*t)(1,14) = -0.07; (*t)(2,14) = 0.07; | |
1779 | (*t)(0,15) = 0.200; (*t)(1,15) = -0.07; (*t)(2,15) = 0.07; | |
1780 | (*t)(0,16) = 0.200; (*t)(1,16) = -0.07; (*t)(2,16) = 0.07; | |
1781 | (*t)(0,17) = 0.850; (*t)(1,17) = -0.070; (*t)(2,17) = 0.070; | |
1782 | (*t)(0,18) = 0.900; (*t)(1,18) = -0.072; (*t)(2,18) = 0.072; | |
1783 | (*t)(0,19) = 0.950; (*t)(1,19) = -0.072; (*t)(2,19) = 0.072; | |
1784 | (*t)(0,20) = 1.000; (*t)(1,20) = -0.074; (*t)(2,20) = 0.074; | |
1785 | (*t)(0,21) = 1.100; (*t)(1,21) = -0.032; (*t)(2,21) = 0.032; | |
1786 | (*t)(0,22) = 1.200; (*t)(1,22) = -0.026; (*t)(2,22) = 0.026; | |
1787 | (*t)(0,23) = 1.300; (*t)(1,23) = -0.026; (*t)(2,23) = 0.026; | |
1788 | (*t)(0,24) = 1.400; (*t)(1,24) = -0.024; (*t)(2,24) = 0.024; | |
1789 | (*t)(0,25) = 1.500; (*t)(1,25) = -0.024; (*t)(2,25) = 0.024; | |
1790 | (*t)(0,26) = 1.600; (*t)(1,26) = -0.026; (*t)(2,26) = 0.026; | |
1791 | (*t)(0,27) = 1.700; (*t)(1,27) = -0.026; (*t)(2,27) = 0.026; | |
1792 | (*t)(0,28) = 1.800; (*t)(1,28) = -0.026; (*t)(2,28) = 0.026; | |
1793 | (*t)(0,29) = 1.900; (*t)(1,29) = -0.026; (*t)(2,29) = 0.026; | |
1794 | (*t)(0,30) = 2.000; (*t)(1,30) = -0.026; (*t)(2,30) = 0.026; | |
1795 | (*t)(0,31) = 2.100; (*t)(1,31) = -0.026; (*t)(2,31) = 0.026; | |
1796 | (*t)(0,32) = 2.200; (*t)(1,32) = -0.026; (*t)(2,32) = 0.024; | |
1797 | (*t)(0,33) = 2.300; (*t)(1,33) = -0.028; (*t)(2,33) = 0.022; | |
1798 | (*t)(0,34) = 2.400; (*t)(1,34) = -0.028; (*t)(2,34) = 0.020; | |
1799 | (*t)(0,35) = 2.500; (*t)(1,35) = -0.028; (*t)(2,35) = 0.018; | |
1800 | (*t)(0,36) = 2.600; (*t)(1,36) = -0.028; (*t)(2,36) = 0.016; | |
1801 | (*t)(0,37) = 2.700; (*t)(1,37) = -0.028; (*t)(2,37) = 0.016; | |
1802 | (*t)(0,38) = 2.800; (*t)(1,38) = -0.030; (*t)(2,38) = 0.014; | |
1803 | (*t)(0,39) = 2.900; (*t)(1,39) = -0.030; (*t)(2,39) = 0.012; | |
1804 | (*t)(0,40) = 3.000; (*t)(1,40) = -0.030; (*t)(2,40) = 0.012; | |
1805 | (*t)(0,41) = 3.100; (*t)(1,41) = -0.030; (*t)(2,41) = 0.010; | |
1806 | (*t)(0,42) = 3.200; (*t)(1,42) = -0.030; (*t)(2,42) = 0.010; | |
1807 | (*t)(0,43) = 3.300; (*t)(1,43) = -0.030; (*t)(2,43) = 0.010; | |
1808 | (*t)(0,44) = 3.400; (*t)(1,44) = -0.030; (*t)(2,44) = 0.008; | |
1809 | (*t)(0,45) = 3.500; (*t)(1,45) = -0.030; (*t)(2,45) = 0.008; | |
1810 | (*t)(0,46) = 3.600; (*t)(1,46) = -0.030; (*t)(2,46) = 0.008; | |
1811 | (*t)(0,47) = 3.700; (*t)(1,47) = -0.030; (*t)(2,47) = 0.006; | |
1812 | (*t)(0,48) = 3.800; (*t)(1,48) = -0.030; (*t)(2,48) = 0.006; | |
1813 | (*t)(0,49) = 3.900; (*t)(1,49) = -0.030; (*t)(2,49) = 0.006; | |
1814 | (*t)(0,50) = 4.000; (*t)(1,50) = -0.028; (*t)(2,50) = 0.004; | |
1815 | (*t)(0,51) = 4.100; (*t)(1,51) = -0.030; (*t)(2,51) = 0.004; | |
1816 | (*t)(0,52) = 4.200; (*t)(1,52) = -0.030; (*t)(2,52) = 0.004; | |
1817 | (*t)(0,53) = 4.300; (*t)(1,53) = -0.028; (*t)(2,53) = 0.002; | |
1818 | (*t)(0,54) = 4.400; (*t)(1,54) = -0.030; (*t)(2,54) = 0.002; | |
1819 | (*t)(0,55) = 4.500; (*t)(1,55) = -0.028; (*t)(2,55) = 0.002; | |
1820 | (*t)(0,56) = 4.600; (*t)(1,56) = -0.028; (*t)(2,56) = 0.002; | |
1821 | (*t)(0,57) = 4.700; (*t)(1,57) = -0.028; (*t)(2,57) = 0.000; | |
1822 | (*t)(0,58) = 4.800; (*t)(1,58) = -0.028; (*t)(2,58) = 0.002; | |
1823 | (*t)(0,59) = 4.900; (*t)(1,59) = 0.000; (*t)(2,59) = 0.000; | |
1824 | (*t)(0,60) = 5.900; (*t)(1,60) = 0.000; (*t)(2,60) = 0.000; | |
1825 | } | |
1826 | else | |
1827 | if (fParticleID==AliPID::kKaon) | |
1828 | { | |
1829 | //TOF kaons, 0.9 purity | |
1830 | t = new TMatrixF(3,61); | |
1831 | (*t)(0,0) = 0.000; (*t)(1,0) = 0.000; (*t)(2,0) = 0.000; | |
1832 | (*t)(0,1) = 0.050; (*t)(1,1) = 0.000; (*t)(2,1) = 0.000; | |
1833 | (*t)(0,2) = 0.100; (*t)(1,2) = 0.000; (*t)(2,2) = 0.000; | |
1834 | (*t)(0,3) = 0.150; (*t)(1,3) = 0.000; (*t)(2,3) = 0.000; | |
1835 | (*t)(0,4) = 0.200; (*t)(1,4) = -0.05; (*t)(2,4) = 0.05; | |
1836 | (*t)(0,5) = 0.200; (*t)(1,5) = -0.05; (*t)(2,5) = 0.05; | |
1837 | (*t)(0,6) = 0.200; (*t)(1,6) = -0.05; (*t)(2,6) = 0.05; | |
1838 | (*t)(0,7) = 0.200; (*t)(1,7) = -0.05; (*t)(2,7) = 0.05; | |
1839 | (*t)(0,8) = 0.200; (*t)(1,8) = -0.05; (*t)(2,8) = 0.05; | |
1840 | (*t)(0,9) = 0.200; (*t)(1,9) = -0.05; (*t)(2,9) = 0.05; | |
1841 | (*t)(0,10) = 0.200; (*t)(1,10) = -0.05; (*t)(2,10) = 0.05; | |
1842 | (*t)(0,11) = 0.550; (*t)(1,11) = -0.026; (*t)(2,11) = 0.026; | |
1843 | (*t)(0,12) = 0.600; (*t)(1,12) = -0.026; (*t)(2,12) = 0.026; | |
1844 | (*t)(0,13) = 0.650; (*t)(1,13) = -0.026; (*t)(2,13) = 0.026; | |
1845 | (*t)(0,14) = 0.700; (*t)(1,14) = -0.026; (*t)(2,14) = 0.026; | |
1846 | (*t)(0,15) = 0.750; (*t)(1,15) = -0.026; (*t)(2,15) = 0.026; | |
1847 | (*t)(0,16) = 0.800; (*t)(1,16) = -0.026; (*t)(2,16) = 0.026; | |
1848 | (*t)(0,17) = 0.850; (*t)(1,17) = -0.024; (*t)(2,17) = 0.024; | |
1849 | (*t)(0,18) = 0.900; (*t)(1,18) = -0.024; (*t)(2,18) = 0.024; | |
1850 | (*t)(0,19) = 0.950; (*t)(1,19) = -0.024; (*t)(2,19) = 0.024; | |
1851 | (*t)(0,20) = 1.000; (*t)(1,20) = -0.024; (*t)(2,20) = 0.024; | |
1852 | (*t)(0,21) = 1.100; (*t)(1,21) = -0.024; (*t)(2,21) = 0.024; | |
1853 | (*t)(0,22) = 1.200; (*t)(1,22) = -0.024; (*t)(2,22) = 0.022; | |
1854 | (*t)(0,23) = 1.300; (*t)(1,23) = -0.024; (*t)(2,23) = 0.020; | |
1855 | (*t)(0,24) = 1.400; (*t)(1,24) = -0.026; (*t)(2,24) = 0.016; | |
1856 | (*t)(0,25) = 1.500; (*t)(1,25) = -0.028; (*t)(2,25) = 0.014; | |
1857 | (*t)(0,26) = 1.600; (*t)(1,26) = -0.028; (*t)(2,26) = 0.012; | |
1858 | (*t)(0,27) = 1.700; (*t)(1,27) = -0.028; (*t)(2,27) = 0.010; | |
1859 | (*t)(0,28) = 1.800; (*t)(1,28) = -0.028; (*t)(2,28) = 0.010; | |
1860 | (*t)(0,29) = 1.900; (*t)(1,29) = -0.028; (*t)(2,29) = 0.008; | |
1861 | (*t)(0,30) = 2.000; (*t)(1,30) = -0.028; (*t)(2,30) = 0.006; | |
1862 | (*t)(0,31) = 2.100; (*t)(1,31) = -0.026; (*t)(2,31) = 0.006; | |
1863 | (*t)(0,32) = 2.200; (*t)(1,32) = -0.024; (*t)(2,32) = 0.004; | |
1864 | (*t)(0,33) = 2.300; (*t)(1,33) = -0.020; (*t)(2,33) = 0.002; | |
1865 | (*t)(0,34) = 2.400; (*t)(1,34) = -0.020; (*t)(2,34) = 0.002; | |
1866 | (*t)(0,35) = 2.500; (*t)(1,35) = -0.018; (*t)(2,35) = 0.000; | |
1867 | (*t)(0,36) = 2.600; (*t)(1,36) = -0.016; (*t)(2,36) = 0.000; | |
1868 | (*t)(0,37) = 2.700; (*t)(1,37) = -0.014; (*t)(2,37) = -0.002; | |
1869 | (*t)(0,38) = 2.800; (*t)(1,38) = -0.014; (*t)(2,38) = -0.004; | |
1870 | (*t)(0,39) = 2.900; (*t)(1,39) = -0.012; (*t)(2,39) = -0.004; | |
1871 | (*t)(0,40) = 3.000; (*t)(1,40) = -0.010; (*t)(2,40) = -0.006; | |
1872 | (*t)(0,41) = 3.100; (*t)(1,41) = 0.000; (*t)(2,41) = 0.000; | |
1873 | (*t)(0,42) = 3.200; (*t)(1,42) = 0.000; (*t)(2,42) = 0.000; | |
1874 | (*t)(0,43) = 3.300; (*t)(1,43) = 0.000; (*t)(2,43) = 0.000; | |
1875 | (*t)(0,44) = 3.400; (*t)(1,44) = 0.000; (*t)(2,44) = 0.000; | |
1876 | (*t)(0,45) = 3.500; (*t)(1,45) = 0.000; (*t)(2,45) = 0.000; | |
1877 | (*t)(0,46) = 3.600; (*t)(1,46) = 0.000; (*t)(2,46) = 0.000; | |
1878 | (*t)(0,47) = 3.700; (*t)(1,47) = 0.000; (*t)(2,47) = 0.000; | |
1879 | (*t)(0,48) = 3.800; (*t)(1,48) = 0.000; (*t)(2,48) = 0.000; | |
1880 | (*t)(0,49) = 3.900; (*t)(1,49) = 0.000; (*t)(2,49) = 0.000; | |
1881 | (*t)(0,50) = 4.000; (*t)(1,50) = 0.000; (*t)(2,50) = 0.000; | |
1882 | (*t)(0,51) = 4.100; (*t)(1,51) = 0.000; (*t)(2,51) = 0.000; | |
1883 | (*t)(0,52) = 4.200; (*t)(1,52) = 0.000; (*t)(2,52) = 0.000; | |
1884 | (*t)(0,53) = 4.300; (*t)(1,53) = 0.000; (*t)(2,53) = 0.000; | |
1885 | (*t)(0,54) = 4.400; (*t)(1,54) = 0.000; (*t)(2,54) = 0.000; | |
1886 | (*t)(0,55) = 4.500; (*t)(1,55) = 0.000; (*t)(2,55) = 0.000; | |
1887 | (*t)(0,56) = 4.600; (*t)(1,56) = 0.000; (*t)(2,56) = 0.000; | |
1888 | (*t)(0,57) = 4.700; (*t)(1,57) = 0.000; (*t)(2,57) = 0.000; | |
1889 | (*t)(0,58) = 4.800; (*t)(1,58) = 0.000; (*t)(2,58) = 0.000; | |
1890 | (*t)(0,59) = 4.900; (*t)(1,59) = 0.000; (*t)(2,59) = 0.000; | |
1891 | (*t)(0,60) = 5.900; (*t)(1,60) = 0.000; (*t)(2,60) = 0.000; | |
1892 | } | |
1893 | delete fTOFpidCuts; | |
1894 | fTOFpidCuts=t; | |
1895 | } | |
1896 | } | |
1897 | ||
1898 | //----------------------------------------------------------------------- | |
1899 | // part added by F. Noferini (some methods) | |
1900 | Bool_t AliFlowTrackCuts::PassesTOFbayesianCut(AliESDtrack* track) | |
1901 | { | |
1902 | ||
1903 | Bool_t goodtrack = track && | |
1904 | (track->GetStatus() & AliESDtrack::kTOFpid) && | |
1905 | (track->GetTOFsignal() > 12000) && | |
1906 | (track->GetTOFsignal() < 100000) && | |
1907 | (track->GetIntegratedLength() > 365); | |
1908 | ||
1909 | if (! fAllowTOFmismatchFlag) {if (track->GetStatus() & AliESDtrack::kTOFmismatch) return kFALSE;} | |
1910 | ||
1911 | if (! goodtrack) | |
1912 | return kFALSE; | |
1913 | ||
1914 | Bool_t statusMatchingHard = TPCTOFagree(track); | |
1915 | if (fRequireStrictTOFTPCagreement && (!statusMatchingHard)) | |
1916 | return kFALSE; | |
1917 | ||
1918 | Int_t pdg = GetESDPdg(track,"bayesianALL"); | |
1919 | // printf("pdg set to %i\n",pdg); | |
1920 | ||
1921 | Int_t pid = 0; | |
1922 | Float_t prob = 0; | |
1923 | switch (fParticleID) | |
1924 | { | |
1925 | case AliPID::kPion: | |
1926 | pid=211; | |
1927 | prob = fProbBayes[2]; | |
1928 | break; | |
1929 | case AliPID::kKaon: | |
1930 | pid=321; | |
1931 | prob = fProbBayes[3]; | |
1932 | break; | |
1933 | case AliPID::kProton: | |
1934 | pid=2212; | |
1935 | prob = fProbBayes[4]; | |
1936 | break; | |
1937 | case AliPID::kElectron: | |
1938 | pid=-11; | |
1939 | prob = fProbBayes[0]; | |
1940 | break; | |
1941 | default: | |
1942 | return kFALSE; | |
1943 | } | |
1944 | ||
1945 | // 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); | |
1946 | if(TMath::Abs(pdg) == TMath::Abs(pid) && prob > fParticleProbability){ | |
1947 | if(!fCutCharge) | |
1948 | return kTRUE; | |
1949 | else if (fCutCharge && fCharge * track->GetSign() > 0) | |
1950 | return kTRUE; | |
1951 | } | |
1952 | return kFALSE; | |
1953 | } | |
1954 | ||
1955 | //----------------------------------------------------------------------- | |
1956 | Int_t AliFlowTrackCuts::GetESDPdg(AliESDtrack *track,Option_t *option,Int_t ipart,Float_t cPi,Float_t cKa,Float_t cPr) | |
1957 | { | |
1958 | //Get ESD Pdg | |
1959 | Int_t pdg = 0; | |
1960 | Int_t pdgvalues[5] = {-11,-13,211,321,2212}; | |
1961 | Float_t mass[5] = {5.10998909999999971e-04,1.05658000000000002e-01,1.39570000000000000e-01,4.93676999999999977e-01,9.38271999999999995e-01}; | |
1962 | ||
1963 | if(strstr(option,"bayesianTOF")){ // Bayesian TOF PID | |
1964 | Double_t c[5]={0.01, 0.01, 0.85, 0.1, 0.05}; | |
1965 | Double_t rcc=0.; | |
1966 | ||
1967 | Float_t pt = track->Pt(); | |
1968 | ||
1969 | Int_t iptesd = 0; | |
1970 | while(pt > fBinLimitPID[iptesd] && iptesd < fgkPIDptBin-1) iptesd++; | |
1971 | ||
1972 | if(cPi < 0){ | |
1973 | c[0] = fC[iptesd][0]; | |
1974 | c[1] = fC[iptesd][1]; | |
1975 | c[2] = fC[iptesd][2]; | |
1976 | c[3] = fC[iptesd][3]; | |
1977 | c[4] = fC[iptesd][4]; | |
1978 | } | |
1979 | else{ | |
1980 | c[0] = 0.0; | |
1981 | c[1] = 0.0; | |
1982 | c[2] = cPi; | |
1983 | c[3] = cKa; | |
1984 | c[4] = cPr; | |
1985 | } | |
1986 | ||
1987 | Double_t r1[10]; track->GetTOFpid(r1); | |
1988 | ||
1989 | Int_t i; | |
1990 | for (i=0; i<5; i++) rcc+=(c[i]*r1[i]); | |
1991 | ||
1992 | Double_t w[10]; | |
1993 | for (i=0; i<5; i++){ | |
1994 | w[i]=c[i]*r1[i]/rcc; | |
1995 | fProbBayes[i] = w[i]; | |
1996 | } | |
1997 | if (w[2]>=w[3] && w[2]>=w[4] && w[2]>=w[1] && w[2]>=w[0]) {//pion | |
1998 | pdg = 211*Int_t(track->GetSign()); | |
1999 | } | |
2000 | else if (w[4]>=w[3] && w[4]>=w[1] && w[4]>=w[0]) {//proton | |
2001 | pdg = 2212*Int_t(track->GetSign()); | |
2002 | } | |
2003 | else if (w[3]>=w[1] && w[3]>=w[0]){//kaon | |
2004 | pdg = 321*Int_t(track->GetSign()); | |
2005 | } | |
2006 | else if (w[0]>=w[1]) { //electrons | |
2007 | pdg = -11*Int_t(track->GetSign()); | |
2008 | } | |
2009 | else{ // muon | |
2010 | pdg = -13*Int_t(track->GetSign()); | |
2011 | } | |
2012 | } | |
2013 | ||
2014 | else if(strstr(option,"bayesianTPC")){ // Bayesian TPC PID | |
2015 | Double_t c[5]={0.01, 0.01, 0.85, 0.1, 0.05}; | |
2016 | Double_t rcc=0.; | |
2017 | ||
2018 | Float_t pt = track->Pt(); | |
2019 | ||
2020 | Int_t iptesd = 0; | |
2021 | while(pt > fBinLimitPID[iptesd] && iptesd < fgkPIDptBin-1) iptesd++; | |
2022 | ||
2023 | if(cPi < 0){ | |
2024 | c[0] = fC[iptesd][0]; | |
2025 | c[1] = fC[iptesd][1]; | |
2026 | c[2] = fC[iptesd][2]; | |
2027 | c[3] = fC[iptesd][3]; | |
2028 | c[4] = fC[iptesd][4]; | |
2029 | } | |
2030 | else{ | |
2031 | c[0] = 0.0; | |
2032 | c[1] = 0.0; | |
2033 | c[2] = cPi; | |
2034 | c[3] = cKa; | |
2035 | c[4] = cPr; | |
2036 | } | |
2037 | ||
2038 | Double_t r1[10]; track->GetTPCpid(r1); | |
2039 | ||
2040 | Int_t i; | |
2041 | for (i=0; i<5; i++) rcc+=(c[i]*r1[i]); | |
2042 | ||
2043 | Double_t w[10]; | |
2044 | for (i=0; i<5; i++){ | |
2045 | w[i]=c[i]*r1[i]/rcc; | |
2046 | fProbBayes[i] = w[i]; | |
2047 | } | |
2048 | if (w[2]>=w[3] && w[2]>=w[4] && w[2]>=w[1] && w[2]>=w[0]) {//pion | |
2049 | pdg = 211*Int_t(track->GetSign()); | |
2050 | } | |
2051 | else if (w[4]>=w[3] && w[4]>=w[1] && w[4]>=w[0]) {//proton | |
2052 | pdg = 2212*Int_t(track->GetSign()); | |
2053 | } | |
2054 | else if (w[3]>=w[1] && w[3]>=w[0]){//kaon | |
2055 | pdg = 321*Int_t(track->GetSign()); | |
2056 | } | |
2057 | else if (w[0]>=w[1]) { //electrons | |
2058 | pdg = -11*Int_t(track->GetSign()); | |
2059 | } | |
2060 | else{ // muon | |
2061 | pdg = -13*Int_t(track->GetSign()); | |
2062 | } | |
2063 | } | |
2064 | ||
2065 | else if(strstr(option,"bayesianALL")){ | |
2066 | Double_t c[5]={0.01, 0.01, 0.85, 0.1, 0.05}; | |
2067 | Double_t rcc=0.; | |
2068 | ||
2069 | Float_t pt = track->Pt(); | |
2070 | ||
2071 | Int_t iptesd = 0; | |
2072 | while(pt > fBinLimitPID[iptesd] && iptesd < fgkPIDptBin-1) iptesd++; | |
2073 | ||
2074 | if(cPi < 0){ | |
2075 | c[0] = fC[iptesd][0]; | |
2076 | c[1] = fC[iptesd][1]; | |
2077 | c[2] = fC[iptesd][2]; | |
2078 | c[3] = fC[iptesd][3]; | |
2079 | c[4] = fC[iptesd][4]; | |
2080 | } | |
2081 | else{ | |
2082 | c[0] = 0.0; | |
2083 | c[1] = 0.0; | |
2084 | c[2] = cPi; | |
2085 | c[3] = cKa; | |
2086 | c[4] = cPr; | |
2087 | } | |
2088 | ||
2089 | Double_t r1[10]; track->GetTOFpid(r1); | |
2090 | Double_t r2[10]; track->GetTPCpid(r2); | |
2091 | ||
2092 | r1[0] = TMath::Min(r1[2],r1[0]); | |
2093 | r1[1] = TMath::Min(r1[2],r1[1]); | |
2094 | ||
2095 | Int_t i; | |
2096 | for (i=0; i<5; i++) rcc+=(c[i]*r1[i]*r2[i]); | |
2097 | ||
2098 | ||
2099 | Double_t w[10]; | |
2100 | for (i=0; i<5; i++){ | |
2101 | w[i]=c[i]*r1[i]*r2[i]/rcc; | |
2102 | fProbBayes[i] = w[i]; | |
2103 | } | |
2104 | ||
2105 | if (w[2]>=w[3] && w[2]>=w[4] && w[2]>=w[1] && w[2]>=w[0]) {//pion | |
2106 | pdg = 211*Int_t(track->GetSign()); | |
2107 | } | |
2108 | else if (w[4]>=w[3] && w[4]>=w[1] && w[4]>=w[0]) {//proton | |
2109 | pdg = 2212*Int_t(track->GetSign()); | |
2110 | } | |
2111 | else if (w[3]>=w[1] && w[3]>=w[0]){//kaon | |
2112 | pdg = 321*Int_t(track->GetSign()); | |
2113 | } | |
2114 | else if (w[0]>=w[1]) { //electrons | |
2115 | pdg = -11*Int_t(track->GetSign()); | |
2116 | } | |
2117 | else{ // muon | |
2118 | pdg = -13*Int_t(track->GetSign()); | |
2119 | } | |
2120 | } | |
2121 | ||
2122 | else if(strstr(option,"sigmacutTOF")){ | |
2123 | printf("PID not implemented yet: %s\nNO PID!!!!\n",option); | |
2124 | Float_t p = track->P(); | |
2125 | ||
2126 | // Take expected times | |
2127 | Double_t exptimes[5]; | |
2128 | track->GetIntegratedTimes(exptimes); | |
2129 | ||
2130 | // Take resolution for TOF response | |
2131 | // like fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[ipart], mass[ipart]); | |
2132 | Float_t resolution = fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[ipart], mass[ipart]); | |
2133 | ||
2134 | if(TMath::Abs(exptimes[ipart] - track->GetTOFsignal()) < 3 * resolution){ | |
2135 | pdg = pdgvalues[ipart] * Int_t(track->GetSign()); | |
2136 | } | |
2137 | } | |
2138 | ||
2139 | else{ | |
2140 | printf("Invalid PID option: %s\nNO PID!!!!\n",option); | |
2141 | } | |
2142 | ||
2143 | return pdg; | |
2144 | } | |
2145 | ||
2146 | //----------------------------------------------------------------------- | |
2147 | void AliFlowTrackCuts::SetPriors(Float_t centrCur){ | |
2148 | fBinLimitPID[0] = 0.300000; | |
2149 | fBinLimitPID[1] = 0.400000; | |
2150 | fBinLimitPID[2] = 0.500000; | |
2151 | fBinLimitPID[3] = 0.600000; | |
2152 | fBinLimitPID[4] = 0.700000; | |
2153 | fBinLimitPID[5] = 0.800000; | |
2154 | fBinLimitPID[6] = 0.900000; | |
2155 | fBinLimitPID[7] = 1.000000; | |
2156 | fBinLimitPID[8] = 1.200000; | |
2157 | fBinLimitPID[9] = 1.400000; | |
2158 | fBinLimitPID[10] = 1.600000; | |
2159 | fBinLimitPID[11] = 1.800000; | |
2160 | fBinLimitPID[12] = 2.000000; | |
2161 | fBinLimitPID[13] = 2.200000; | |
2162 | fBinLimitPID[14] = 2.400000; | |
2163 | fBinLimitPID[15] = 2.600000; | |
2164 | fBinLimitPID[16] = 2.800000; | |
2165 | fBinLimitPID[17] = 3.000000; | |
2166 | ||
2167 | // 0-10% | |
2168 | if(centrCur < 10){ | |
2169 | fC[0][0] = 0.005; | |
2170 | fC[0][1] = 0.005; | |
2171 | fC[0][2] = 1.0000; | |
2172 | fC[0][3] = 0.0010; | |
2173 | fC[0][4] = 0.0010; | |
2174 | ||
2175 | fC[1][0] = 0.005; | |
2176 | fC[1][1] = 0.005; | |
2177 | fC[1][2] = 1.0000; | |
2178 | fC[1][3] = 0.0168; | |
2179 | fC[1][4] = 0.0122; | |
2180 | ||
2181 | fC[2][0] = 0.005; | |
2182 | fC[2][1] = 0.005; | |
2183 | fC[2][2] = 1.0000; | |
2184 | fC[2][3] = 0.0272; | |
2185 | fC[2][4] = 0.0070; | |
2186 | ||
2187 | fC[3][0] = 0.005; | |
2188 | fC[3][1] = 0.005; | |
2189 | fC[3][2] = 1.0000; | |
2190 | fC[3][3] = 0.0562; | |
2191 | fC[3][4] = 0.0258; | |
2192 | ||
2193 | fC[4][0] = 0.005; | |
2194 | fC[4][1] = 0.005; | |
2195 | fC[4][2] = 1.0000; | |
2196 | fC[4][3] = 0.0861; | |
2197 | fC[4][4] = 0.0496; | |
2198 | ||
2199 | fC[5][0] = 0.005; | |
2200 | fC[5][1] = 0.005; | |
2201 | fC[5][2] = 1.0000; | |
2202 | fC[5][3] = 0.1168; | |
2203 | fC[5][4] = 0.0740; | |
2204 | ||
2205 | fC[6][0] = 0.005; | |
2206 | fC[6][1] = 0.005; | |
2207 | fC[6][2] = 1.0000; | |
2208 | fC[6][3] = 0.1476; | |
2209 | fC[6][4] = 0.0998; | |
2210 | ||
2211 | fC[7][0] = 0.005; | |
2212 | fC[7][1] = 0.005; | |
2213 | fC[7][2] = 1.0000; | |
2214 | fC[7][3] = 0.1810; | |
2215 | fC[7][4] = 0.1296; | |
2216 | ||
2217 | fC[8][0] = 0.005; | |
2218 | fC[8][1] = 0.005; | |
2219 | fC[8][2] = 1.0000; | |
2220 | fC[8][3] = 0.2240; | |
2221 | fC[8][4] = 0.1827; | |
2222 | ||
2223 | fC[9][0] = 0.005; | |
2224 | fC[9][1] = 0.005; | |
2225 | fC[9][2] = 1.0000; | |
2226 | fC[9][3] = 0.2812; | |
2227 | fC[9][4] = 0.2699; | |
2228 | ||
2229 | fC[10][0] = 0.005; | |
2230 | fC[10][1] = 0.005; | |
2231 | fC[10][2] = 1.0000; | |
2232 | fC[10][3] = 0.3328; | |
2233 | fC[10][4] = 0.3714; | |
2234 | ||
2235 | fC[11][0] = 0.005; | |
2236 | fC[11][1] = 0.005; | |
2237 | fC[11][2] = 1.0000; | |
2238 | fC[11][3] = 0.3780; | |
2239 | fC[11][4] = 0.4810; | |
2240 | ||
2241 | fC[12][0] = 0.005; | |
2242 | fC[12][1] = 0.005; | |
2243 | fC[12][2] = 1.0000; | |
2244 | fC[12][3] = 0.4125; | |
2245 | fC[12][4] = 0.5771; | |
2246 | ||
2247 | fC[13][0] = 0.005; | |
2248 | fC[13][1] = 0.005; | |
2249 | fC[13][2] = 1.0000; | |
2250 | fC[13][3] = 0.4486; | |
2251 | fC[13][4] = 0.6799; | |
2252 | ||
2253 | fC[14][0] = 0.005; | |
2254 | fC[14][1] = 0.005; | |
2255 | fC[14][2] = 1.0000; | |
2256 | fC[14][3] = 0.4840; | |
2257 | fC[14][4] = 0.7668; | |
2258 | ||
2259 | fC[15][0] = 0.005; | |
2260 | fC[15][1] = 0.005; | |
2261 | fC[15][2] = 1.0000; | |
2262 | fC[15][3] = 0.4971; | |
2263 | fC[15][4] = 0.8288; | |
2264 | ||
2265 | fC[16][0] = 0.005; | |
2266 | fC[16][1] = 0.005; | |
2267 | fC[16][2] = 1.0000; | |
2268 | fC[16][3] = 0.4956; | |
2269 | fC[16][4] = 0.8653; | |
2270 | ||
2271 | fC[17][0] = 0.005; | |
2272 | fC[17][1] = 0.005; | |
2273 | fC[17][2] = 1.0000; | |
2274 | fC[17][3] = 0.5173; | |
2275 | fC[17][4] = 0.9059; | |
2276 | } | |
2277 | // 10-20% | |
2278 | else if(centrCur < 20){ | |
2279 | fC[0][0] = 0.005; | |
2280 | fC[0][1] = 0.005; | |
2281 | fC[0][2] = 1.0000; | |
2282 | fC[0][3] = 0.0010; | |
2283 | fC[0][4] = 0.0010; | |
2284 | ||
2285 | fC[1][0] = 0.005; | |
2286 | fC[1][1] = 0.005; | |
2287 | fC[1][2] = 1.0000; | |
2288 | fC[1][3] = 0.0132; | |
2289 | fC[1][4] = 0.0088; | |
2290 | ||
2291 | fC[2][0] = 0.005; | |
2292 | fC[2][1] = 0.005; | |
2293 | fC[2][2] = 1.0000; | |
2294 | fC[2][3] = 0.0283; | |
2295 | fC[2][4] = 0.0068; | |
2296 | ||
2297 | fC[3][0] = 0.005; | |
2298 | fC[3][1] = 0.005; | |
2299 | fC[3][2] = 1.0000; | |
2300 | fC[3][3] = 0.0577; | |
2301 | fC[3][4] = 0.0279; | |
2302 | ||
2303 | fC[4][0] = 0.005; | |
2304 | fC[4][1] = 0.005; | |
2305 | fC[4][2] = 1.0000; | |
2306 | fC[4][3] = 0.0884; | |
2307 | fC[4][4] = 0.0534; | |
2308 | ||
2309 | fC[5][0] = 0.005; | |
2310 | fC[5][1] = 0.005; | |
2311 | fC[5][2] = 1.0000; | |
2312 | fC[5][3] = 0.1179; | |
2313 | fC[5][4] = 0.0794; | |
2314 | ||
2315 | fC[6][0] = 0.005; | |
2316 | fC[6][1] = 0.005; | |
2317 | fC[6][2] = 1.0000; | |
2318 | fC[6][3] = 0.1480; | |
2319 | fC[6][4] = 0.1058; | |
2320 | ||
2321 | fC[7][0] = 0.005; | |
2322 | fC[7][1] = 0.005; | |
2323 | fC[7][2] = 1.0000; | |
2324 | fC[7][3] = 0.1807; | |
2325 | fC[7][4] = 0.1366; | |
2326 | ||
2327 | fC[8][0] = 0.005; | |
2328 | fC[8][1] = 0.005; | |
2329 | fC[8][2] = 1.0000; | |
2330 | fC[8][3] = 0.2219; | |
2331 | fC[8][4] = 0.1891; | |
2332 | ||
2333 | fC[9][0] = 0.005; | |
2334 | fC[9][1] = 0.005; | |
2335 | fC[9][2] = 1.0000; | |
2336 | fC[9][3] = 0.2804; | |
2337 | fC[9][4] = 0.2730; | |
2338 | ||
2339 | fC[10][0] = 0.005; | |
2340 | fC[10][1] = 0.005; | |
2341 | fC[10][2] = 1.0000; | |
2342 | fC[10][3] = 0.3283; | |
2343 | fC[10][4] = 0.3660; | |
2344 | ||
2345 | fC[11][0] = 0.005; | |
2346 | fC[11][1] = 0.005; | |
2347 | fC[11][2] = 1.0000; | |
2348 | fC[11][3] = 0.3710; | |
2349 | fC[11][4] = 0.4647; | |
2350 | ||
2351 | fC[12][0] = 0.005; | |
2352 | fC[12][1] = 0.005; | |
2353 | fC[12][2] = 1.0000; | |
2354 | fC[12][3] = 0.4093; | |
2355 | fC[12][4] = 0.5566; | |
2356 | ||
2357 | fC[13][0] = 0.005; | |
2358 | fC[13][1] = 0.005; | |
2359 | fC[13][2] = 1.0000; | |
2360 | fC[13][3] = 0.4302; | |
2361 | fC[13][4] = 0.6410; | |
2362 | ||
2363 | fC[14][0] = 0.005; | |
2364 | fC[14][1] = 0.005; | |
2365 | fC[14][2] = 1.0000; | |
2366 | fC[14][3] = 0.4649; | |
2367 | fC[14][4] = 0.7055; | |
2368 | ||
2369 | fC[15][0] = 0.005; | |
2370 | fC[15][1] = 0.005; | |
2371 | fC[15][2] = 1.0000; | |
2372 | fC[15][3] = 0.4523; | |
2373 | fC[15][4] = 0.7440; | |
2374 | ||
2375 | fC[16][0] = 0.005; | |
2376 | fC[16][1] = 0.005; | |
2377 | fC[16][2] = 1.0000; | |
2378 | fC[16][3] = 0.4591; | |
2379 | fC[16][4] = 0.7799; | |
2380 | ||
2381 | fC[17][0] = 0.005; | |
2382 | fC[17][1] = 0.005; | |
2383 | fC[17][2] = 1.0000; | |
2384 | fC[17][3] = 0.4804; | |
2385 | fC[17][4] = 0.8218; | |
2386 | } | |
2387 | // 20-30% | |
2388 | else if(centrCur < 30){ | |
2389 | fC[0][0] = 0.005; | |
2390 | fC[0][1] = 0.005; | |
2391 | fC[0][2] = 1.0000; | |
2392 | fC[0][3] = 0.0010; | |
2393 | fC[0][4] = 0.0010; | |
2394 | ||
2395 | fC[1][0] = 0.005; | |
2396 | fC[1][1] = 0.005; | |
2397 | fC[1][2] = 1.0000; | |
2398 | fC[1][3] = 0.0102; | |
2399 | fC[1][4] = 0.0064; | |
2400 | ||
2401 | fC[2][0] = 0.005; | |
2402 | fC[2][1] = 0.005; | |
2403 | fC[2][2] = 1.0000; | |
2404 | fC[2][3] = 0.0292; | |
2405 | fC[2][4] = 0.0066; | |
2406 | ||
2407 | fC[3][0] = 0.005; | |
2408 | fC[3][1] = 0.005; | |
2409 | fC[3][2] = 1.0000; | |
2410 | fC[3][3] = 0.0597; | |
2411 | fC[3][4] = 0.0296; | |
2412 | ||
2413 | fC[4][0] = 0.005; | |
2414 | fC[4][1] = 0.005; | |
2415 | fC[4][2] = 1.0000; | |
2416 | fC[4][3] = 0.0900; | |
2417 | fC[4][4] = 0.0589; | |
2418 | ||
2419 | fC[5][0] = 0.005; | |
2420 | fC[5][1] = 0.005; | |
2421 | fC[5][2] = 1.0000; | |
2422 | fC[5][3] = 0.1199; | |
2423 | fC[5][4] = 0.0859; | |
2424 | ||
2425 | fC[6][0] = 0.005; | |
2426 | fC[6][1] = 0.005; | |
2427 | fC[6][2] = 1.0000; | |
2428 | fC[6][3] = 0.1505; | |
2429 | fC[6][4] = 0.1141; | |
2430 | ||
2431 | fC[7][0] = 0.005; | |
2432 | fC[7][1] = 0.005; | |
2433 | fC[7][2] = 1.0000; | |
2434 | fC[7][3] = 0.1805; | |
2435 | fC[7][4] = 0.1454; | |
2436 | ||
2437 | fC[8][0] = 0.005; | |
2438 | fC[8][1] = 0.005; | |
2439 | fC[8][2] = 1.0000; | |
2440 | fC[8][3] = 0.2221; | |
2441 | fC[8][4] = 0.2004; | |
2442 | ||
2443 | fC[9][0] = 0.005; | |
2444 | fC[9][1] = 0.005; | |
2445 | fC[9][2] = 1.0000; | |
2446 | fC[9][3] = 0.2796; | |
2447 | fC[9][4] = 0.2838; | |
2448 | ||
2449 | fC[10][0] = 0.005; | |
2450 | fC[10][1] = 0.005; | |
2451 | fC[10][2] = 1.0000; | |
2452 | fC[10][3] = 0.3271; | |
2453 | fC[10][4] = 0.3682; | |
2454 | ||
2455 | fC[11][0] = 0.005; | |
2456 | fC[11][1] = 0.005; | |
2457 | fC[11][2] = 1.0000; | |
2458 | fC[11][3] = 0.3648; | |
2459 | fC[11][4] = 0.4509; | |
2460 | ||
2461 | fC[12][0] = 0.005; | |
2462 | fC[12][1] = 0.005; | |
2463 | fC[12][2] = 1.0000; | |
2464 | fC[12][3] = 0.3988; | |
2465 | fC[12][4] = 0.5339; | |
2466 | ||
2467 | fC[13][0] = 0.005; | |
2468 | fC[13][1] = 0.005; | |
2469 | fC[13][2] = 1.0000; | |
2470 | fC[13][3] = 0.4315; | |
2471 | fC[13][4] = 0.5995; | |
2472 | ||
2473 | fC[14][0] = 0.005; | |
2474 | fC[14][1] = 0.005; | |
2475 | fC[14][2] = 1.0000; | |
2476 | fC[14][3] = 0.4548; | |
2477 | fC[14][4] = 0.6612; | |
2478 | ||
2479 | fC[15][0] = 0.005; | |
2480 | fC[15][1] = 0.005; | |
2481 | fC[15][2] = 1.0000; | |
2482 | fC[15][3] = 0.4744; | |
2483 | fC[15][4] = 0.7060; | |
2484 | ||
2485 | fC[16][0] = 0.005; | |
2486 | fC[16][1] = 0.005; | |
2487 | fC[16][2] = 1.0000; | |
2488 | fC[16][3] = 0.4899; | |
2489 | fC[16][4] = 0.7388; | |
2490 | ||
2491 | fC[17][0] = 0.005; | |
2492 | fC[17][1] = 0.005; | |
2493 | fC[17][2] = 1.0000; | |
2494 | fC[17][3] = 0.4411; | |
2495 | fC[17][4] = 0.7293; | |
2496 | } | |
2497 | // 30-40% | |
2498 | else if(centrCur < 40){ | |
2499 | fC[0][0] = 0.005; | |
2500 | fC[0][1] = 0.005; | |
2501 | fC[0][2] = 1.0000; | |
2502 | fC[0][3] = 0.0010; | |
2503 | fC[0][4] = 0.0010; | |
2504 | ||
2505 | fC[1][0] = 0.005; | |
2506 | fC[1][1] = 0.005; | |
2507 | fC[1][2] = 1.0000; | |
2508 | fC[1][3] = 0.0102; | |
2509 | fC[1][4] = 0.0048; | |
2510 | ||
2511 | fC[2][0] = 0.005; | |
2512 | fC[2][1] = 0.005; | |
2513 | fC[2][2] = 1.0000; | |
2514 | fC[2][3] = 0.0306; | |
2515 | fC[2][4] = 0.0079; | |
2516 | ||
2517 | fC[3][0] = 0.005; | |
2518 | fC[3][1] = 0.005; | |
2519 | fC[3][2] = 1.0000; | |
2520 | fC[3][3] = 0.0617; | |
2521 | fC[3][4] = 0.0338; | |
2522 | ||
2523 | fC[4][0] = 0.005; | |
2524 | fC[4][1] = 0.005; | |
2525 | fC[4][2] = 1.0000; | |
2526 | fC[4][3] = 0.0920; | |
2527 | fC[4][4] = 0.0652; | |
2528 | ||
2529 | fC[5][0] = 0.005; | |
2530 | fC[5][1] = 0.005; | |
2531 | fC[5][2] = 1.0000; | |
2532 | fC[5][3] = 0.1211; | |
2533 | fC[5][4] = 0.0955; | |
2534 | ||
2535 | fC[6][0] = 0.005; | |
2536 | fC[6][1] = 0.005; | |
2537 | fC[6][2] = 1.0000; | |
2538 | fC[6][3] = 0.1496; | |
2539 | fC[6][4] = 0.1242; | |
2540 | ||
2541 | fC[7][0] = 0.005; | |
2542 | fC[7][1] = 0.005; | |
2543 | fC[7][2] = 1.0000; | |
2544 | fC[7][3] = 0.1807; | |
2545 | fC[7][4] = 0.1576; | |
2546 | ||
2547 | fC[8][0] = 0.005; | |
2548 | fC[8][1] = 0.005; | |
2549 | fC[8][2] = 1.0000; | |
2550 | fC[8][3] = 0.2195; | |
2551 | fC[8][4] = 0.2097; | |
2552 | ||
2553 | fC[9][0] = 0.005; | |
2554 | fC[9][1] = 0.005; | |
2555 | fC[9][2] = 1.0000; | |
2556 | fC[9][3] = 0.2732; | |
2557 | fC[9][4] = 0.2884; | |
2558 | ||
2559 | fC[10][0] = 0.005; | |
2560 | fC[10][1] = 0.005; | |
2561 | fC[10][2] = 1.0000; | |
2562 | fC[10][3] = 0.3204; | |
2563 | fC[10][4] = 0.3679; | |
2564 | ||
2565 | fC[11][0] = 0.005; | |
2566 | fC[11][1] = 0.005; | |
2567 | fC[11][2] = 1.0000; | |
2568 | fC[11][3] = 0.3564; | |
2569 | fC[11][4] = 0.4449; | |
2570 | ||
2571 | fC[12][0] = 0.005; | |
2572 | fC[12][1] = 0.005; | |
2573 | fC[12][2] = 1.0000; | |
2574 | fC[12][3] = 0.3791; | |
2575 | fC[12][4] = 0.5052; | |
2576 | ||
2577 | fC[13][0] = 0.005; | |
2578 | fC[13][1] = 0.005; | |
2579 | fC[13][2] = 1.0000; | |
2580 | fC[13][3] = 0.4062; | |
2581 | fC[13][4] = 0.5647; | |
2582 | ||
2583 | fC[14][0] = 0.005; | |
2584 | fC[14][1] = 0.005; | |
2585 | fC[14][2] = 1.0000; | |
2586 | fC[14][3] = 0.4234; | |
2587 | fC[14][4] = 0.6203; | |
2588 | ||
2589 | fC[15][0] = 0.005; | |
2590 | fC[15][1] = 0.005; | |
2591 | fC[15][2] = 1.0000; | |
2592 | fC[15][3] = 0.4441; | |
2593 | fC[15][4] = 0.6381; | |
2594 | ||
2595 | fC[16][0] = 0.005; | |
2596 | fC[16][1] = 0.005; | |
2597 | fC[16][2] = 1.0000; | |
2598 | fC[16][3] = 0.4629; | |
2599 | fC[16][4] = 0.6496; | |
2600 | ||
2601 | fC[17][0] = 0.005; | |
2602 | fC[17][1] = 0.005; | |
2603 | fC[17][2] = 1.0000; | |
2604 | fC[17][3] = 0.4293; | |
2605 | fC[17][4] = 0.6491; | |
2606 | } | |
2607 | // 40-50% | |
2608 | else if(centrCur < 50){ | |
2609 | fC[0][0] = 0.005; | |
2610 | fC[0][1] = 0.005; | |
2611 | fC[0][2] = 1.0000; | |
2612 | fC[0][3] = 0.0010; | |
2613 | fC[0][4] = 0.0010; | |
2614 | ||
2615 | fC[1][0] = 0.005; | |
2616 | fC[1][1] = 0.005; | |
2617 | fC[1][2] = 1.0000; | |
2618 | fC[1][3] = 0.0093; | |
2619 | fC[1][4] = 0.0057; | |
2620 | ||
2621 | fC[2][0] = 0.005; | |
2622 | fC[2][1] = 0.005; | |
2623 | fC[2][2] = 1.0000; | |
2624 | fC[2][3] = 0.0319; | |
2625 | fC[2][4] = 0.0075; | |
2626 | ||
2627 | fC[3][0] = 0.005; | |
2628 | fC[3][1] = 0.005; | |
2629 | fC[3][2] = 1.0000; | |
2630 | fC[3][3] = 0.0639; | |
2631 | fC[3][4] = 0.0371; | |
2632 | ||
2633 | fC[4][0] = 0.005; | |
2634 | fC[4][1] = 0.005; | |
2635 | fC[4][2] = 1.0000; | |
2636 | fC[4][3] = 0.0939; | |
2637 | fC[4][4] = 0.0725; | |
2638 | ||
2639 | fC[5][0] = 0.005; | |
2640 | fC[5][1] = 0.005; | |
2641 | fC[5][2] = 1.0000; | |
2642 | fC[5][3] = 0.1224; | |
2643 | fC[5][4] = 0.1045; | |
2644 | ||
2645 | fC[6][0] = 0.005; | |
2646 | fC[6][1] = 0.005; | |
2647 | fC[6][2] = 1.0000; | |
2648 | fC[6][3] = 0.1520; | |
2649 | fC[6][4] = 0.1387; | |
2650 | ||
2651 | fC[7][0] = 0.005; | |
2652 | fC[7][1] = 0.005; | |
2653 | fC[7][2] = 1.0000; | |
2654 | fC[7][3] = 0.1783; | |
2655 | fC[7][4] = 0.1711; | |
2656 | ||
2657 | fC[8][0] = 0.005; | |
2658 | fC[8][1] = 0.005; | |
2659 | fC[8][2] = 1.0000; | |
2660 | fC[8][3] = 0.2202; | |
2661 | fC[8][4] = 0.2269; | |
2662 | ||
2663 | fC[9][0] = 0.005; | |
2664 | fC[9][1] = 0.005; | |
2665 | fC[9][2] = 1.0000; | |
2666 | fC[9][3] = 0.2672; | |
2667 | fC[9][4] = 0.2955; | |
2668 | ||
2669 | fC[10][0] = 0.005; | |
2670 | fC[10][1] = 0.005; | |
2671 | fC[10][2] = 1.0000; | |
2672 | fC[10][3] = 0.3191; | |
2673 | fC[10][4] = 0.3676; | |
2674 | ||
2675 | fC[11][0] = 0.005; | |
2676 | fC[11][1] = 0.005; | |
2677 | fC[11][2] = 1.0000; | |
2678 | fC[11][3] = 0.3434; | |
2679 | fC[11][4] = 0.4321; | |
2680 | ||
2681 | fC[12][0] = 0.005; | |
2682 | fC[12][1] = 0.005; | |
2683 | fC[12][2] = 1.0000; | |
2684 | fC[12][3] = 0.3692; | |
2685 | fC[12][4] = 0.4879; | |
2686 | ||
2687 | fC[13][0] = 0.005; | |
2688 | fC[13][1] = 0.005; | |
2689 | fC[13][2] = 1.0000; | |
2690 | fC[13][3] = 0.3993; | |
2691 | fC[13][4] = 0.5377; | |
2692 | ||
2693 | fC[14][0] = 0.005; | |
2694 | fC[14][1] = 0.005; | |
2695 | fC[14][2] = 1.0000; | |
2696 | fC[14][3] = 0.3818; | |
2697 | fC[14][4] = 0.5547; | |
2698 | ||
2699 | fC[15][0] = 0.005; | |
2700 | fC[15][1] = 0.005; | |
2701 | fC[15][2] = 1.0000; | |
2702 | fC[15][3] = 0.4003; | |
2703 | fC[15][4] = 0.5484; | |
2704 | ||
2705 | fC[16][0] = 0.005; | |
2706 | fC[16][1] = 0.005; | |
2707 | fC[16][2] = 1.0000; | |
2708 | fC[16][3] = 0.4281; | |
2709 | fC[16][4] = 0.5383; | |
2710 | ||
2711 | fC[17][0] = 0.005; | |
2712 | fC[17][1] = 0.005; | |
2713 | fC[17][2] = 1.0000; | |
2714 | fC[17][3] = 0.3960; | |
2715 | fC[17][4] = 0.5374; | |
2716 | } | |
2717 | // 50-60% | |
2718 | else if(centrCur < 60){ | |
2719 | fC[0][0] = 0.005; | |
2720 | fC[0][1] = 0.005; | |
2721 | fC[0][2] = 1.0000; | |
2722 | fC[0][3] = 0.0010; | |
2723 | fC[0][4] = 0.0010; | |
2724 | ||
2725 | fC[1][0] = 0.005; | |
2726 | fC[1][1] = 0.005; | |
2727 | fC[1][2] = 1.0000; | |
2728 | fC[1][3] = 0.0076; | |
2729 | fC[1][4] = 0.0032; | |
2730 | ||
2731 | fC[2][0] = 0.005; | |
2732 | fC[2][1] = 0.005; | |
2733 | fC[2][2] = 1.0000; | |
2734 | fC[2][3] = 0.0329; | |
2735 | fC[2][4] = 0.0085; | |
2736 | ||
2737 | fC[3][0] = 0.005; | |
2738 | fC[3][1] = 0.005; | |
2739 | fC[3][2] = 1.0000; | |
2740 | fC[3][3] = 0.0653; | |
2741 | fC[3][4] = 0.0423; | |
2742 | ||
2743 | fC[4][0] = 0.005; | |
2744 | fC[4][1] = 0.005; | |
2745 | fC[4][2] = 1.0000; | |
2746 | fC[4][3] = 0.0923; | |
2747 | fC[4][4] = 0.0813; | |
2748 | ||
2749 | fC[5][0] = 0.005; | |
2750 | fC[5][1] = 0.005; | |
2751 | fC[5][2] = 1.0000; | |
2752 | fC[5][3] = 0.1219; | |
2753 | fC[5][4] = 0.1161; | |
2754 | ||
2755 | fC[6][0] = 0.005; | |
2756 | fC[6][1] = 0.005; | |
2757 | fC[6][2] = 1.0000; | |
2758 | fC[6][3] = 0.1519; | |
2759 | fC[6][4] = 0.1520; | |
2760 | ||
2761 | fC[7][0] = 0.005; | |
2762 | fC[7][1] = 0.005; | |
2763 | fC[7][2] = 1.0000; | |
2764 | fC[7][3] = 0.1763; | |
2765 | fC[7][4] = 0.1858; | |
2766 | ||
2767 | fC[8][0] = 0.005; | |
2768 | fC[8][1] = 0.005; | |
2769 | fC[8][2] = 1.0000; | |
2770 | fC[8][3] = 0.2178; | |
2771 | fC[8][4] = 0.2385; | |
2772 | ||
2773 | fC[9][0] = 0.005; | |
2774 | fC[9][1] = 0.005; | |
2775 | fC[9][2] = 1.0000; | |
2776 | fC[9][3] = 0.2618; | |
2777 | fC[9][4] = 0.3070; | |
2778 | ||
2779 | fC[10][0] = 0.005; | |
2780 | fC[10][1] = 0.005; | |
2781 | fC[10][2] = 1.0000; | |
2782 | fC[10][3] = 0.3067; | |
2783 | fC[10][4] = 0.3625; | |
2784 | ||
2785 | fC[11][0] = 0.005; | |
2786 | fC[11][1] = 0.005; | |
2787 | fC[11][2] = 1.0000; | |
2788 | fC[11][3] = 0.3336; | |
2789 | fC[11][4] = 0.4188; | |
2790 | ||
2791 | fC[12][0] = 0.005; | |
2792 | fC[12][1] = 0.005; | |
2793 | fC[12][2] = 1.0000; | |
2794 | fC[12][3] = 0.3706; | |
2795 | fC[12][4] = 0.4511; | |
2796 | ||
2797 | fC[13][0] = 0.005; | |
2798 | fC[13][1] = 0.005; | |
2799 | fC[13][2] = 1.0000; | |
2800 | fC[13][3] = 0.3765; | |
2801 | fC[13][4] = 0.4729; | |
2802 | ||
2803 | fC[14][0] = 0.005; | |
2804 | fC[14][1] = 0.005; | |
2805 | fC[14][2] = 1.0000; | |
2806 | fC[14][3] = 0.3942; | |
2807 | fC[14][4] = 0.4855; | |
2808 | ||
2809 | fC[15][0] = 0.005; | |
2810 | fC[15][1] = 0.005; | |
2811 | fC[15][2] = 1.0000; | |
2812 | fC[15][3] = 0.4051; | |
2813 | fC[15][4] = 0.4762; | |
2814 | ||
2815 | fC[16][0] = 0.005; | |
2816 | fC[16][1] = 0.005; | |
2817 | fC[16][2] = 1.0000; | |
2818 | fC[16][3] = 0.3843; | |
2819 | fC[16][4] = 0.4763; | |
2820 | ||
2821 | fC[17][0] = 0.005; | |
2822 | fC[17][1] = 0.005; | |
2823 | fC[17][2] = 1.0000; | |
2824 | fC[17][3] = 0.4237; | |
2825 | fC[17][4] = 0.4773; | |
2826 | } | |
2827 | // 60-70% | |
2828 | else if(centrCur < 70){ | |
2829 | fC[0][0] = 0.005; | |
2830 | fC[0][1] = 0.005; | |
2831 | fC[0][2] = 1.0000; | |
2832 | fC[0][3] = 0.0010; | |
2833 | fC[0][4] = 0.0010; | |
2834 | ||
2835 | fC[1][0] = 0.005; | |
2836 | fC[1][1] = 0.005; | |
2837 | fC[1][2] = 1.0000; | |
2838 | fC[1][3] = 0.0071; | |
2839 | fC[1][4] = 0.0012; | |
2840 | ||
2841 | fC[2][0] = 0.005; | |
2842 | fC[2][1] = 0.005; | |
2843 | fC[2][2] = 1.0000; | |
2844 | fC[2][3] = 0.0336; | |
2845 | fC[2][4] = 0.0097; | |
2846 | ||
2847 | fC[3][0] = 0.005; | |
2848 | fC[3][1] = 0.005; | |
2849 | fC[3][2] = 1.0000; | |
2850 | fC[3][3] = 0.0662; | |
2851 | fC[3][4] = 0.0460; | |
2852 | ||
2853 | fC[4][0] = 0.005; | |
2854 | fC[4][1] = 0.005; | |
2855 | fC[4][2] = 1.0000; | |
2856 | fC[4][3] = 0.0954; | |
2857 | fC[4][4] = 0.0902; | |
2858 | ||
2859 | fC[5][0] = 0.005; | |
2860 | fC[5][1] = 0.005; | |
2861 | fC[5][2] = 1.0000; | |
2862 | fC[5][3] = 0.1181; | |
2863 | fC[5][4] = 0.1306; | |
2864 | ||
2865 | fC[6][0] = 0.005; | |
2866 | fC[6][1] = 0.005; | |
2867 | fC[6][2] = 1.0000; | |
2868 | fC[6][3] = 0.1481; | |
2869 | fC[6][4] = 0.1662; | |
2870 | ||
2871 | fC[7][0] = 0.005; | |
2872 | fC[7][1] = 0.005; | |
2873 | fC[7][2] = 1.0000; | |
2874 | fC[7][3] = 0.1765; | |
2875 | fC[7][4] = 0.1963; | |
2876 | ||
2877 | fC[8][0] = 0.005; | |
2878 | fC[8][1] = 0.005; | |
2879 | fC[8][2] = 1.0000; | |
2880 | fC[8][3] = 0.2155; | |
2881 | fC[8][4] = 0.2433; | |
2882 | ||
2883 | fC[9][0] = 0.005; | |
2884 | fC[9][1] = 0.005; | |
2885 | fC[9][2] = 1.0000; | |
2886 | fC[9][3] = 0.2580; | |
2887 | fC[9][4] = 0.3022; | |
2888 | ||
2889 | fC[10][0] = 0.005; | |
2890 | fC[10][1] = 0.005; | |
2891 | fC[10][2] = 1.0000; | |
2892 | fC[10][3] = 0.2872; | |
2893 | fC[10][4] = 0.3481; | |
2894 | ||
2895 | fC[11][0] = 0.005; | |
2896 | fC[11][1] = 0.005; | |
2897 | fC[11][2] = 1.0000; | |
2898 | fC[11][3] = 0.3170; | |
2899 | fC[11][4] = 0.3847; | |
2900 | ||
2901 | fC[12][0] = 0.005; | |
2902 | fC[12][1] = 0.005; | |
2903 | fC[12][2] = 1.0000; | |
2904 | fC[12][3] = 0.3454; | |
2905 | fC[12][4] = 0.4258; | |
2906 | ||
2907 | fC[13][0] = 0.005; | |
2908 | fC[13][1] = 0.005; | |
2909 | fC[13][2] = 1.0000; | |
2910 | fC[13][3] = 0.3580; | |
2911 | fC[13][4] = 0.4299; | |
2912 | ||
2913 | fC[14][0] = 0.005; | |
2914 | fC[14][1] = 0.005; | |
2915 | fC[14][2] = 1.0000; | |
2916 | fC[14][3] = 0.3903; | |
2917 | fC[14][4] = 0.4326; | |
2918 | ||
2919 | fC[15][0] = 0.005; | |
2920 | fC[15][1] = 0.005; | |
2921 | fC[15][2] = 1.0000; | |
2922 | fC[15][3] = 0.3690; | |
2923 | fC[15][4] = 0.4491; | |
2924 | ||
2925 | fC[16][0] = 0.005; | |
2926 | fC[16][1] = 0.005; | |
2927 | fC[16][2] = 1.0000; | |
2928 | fC[16][3] = 0.4716; | |
2929 | fC[16][4] = 0.4298; | |
2930 | ||
2931 | fC[17][0] = 0.005; | |
2932 | fC[17][1] = 0.005; | |
2933 | fC[17][2] = 1.0000; | |
2934 | fC[17][3] = 0.3875; | |
2935 | fC[17][4] = 0.4083; | |
2936 | } | |
2937 | // 70-80% | |
2938 | else if(centrCur < 80){ | |
2939 | fC[0][0] = 0.005; | |
2940 | fC[0][1] = 0.005; | |
2941 | fC[0][2] = 1.0000; | |
2942 | fC[0][3] = 0.0010; | |
2943 | fC[0][4] = 0.0010; | |
2944 | ||
2945 | fC[1][0] = 0.005; | |
2946 | fC[1][1] = 0.005; | |
2947 | fC[1][2] = 1.0000; | |
2948 | fC[1][3] = 0.0075; | |
2949 | fC[1][4] = 0.0007; | |
2950 | ||
2951 | fC[2][0] = 0.005; | |
2952 | fC[2][1] = 0.005; | |
2953 | fC[2][2] = 1.0000; | |
2954 | fC[2][3] = 0.0313; | |
2955 | fC[2][4] = 0.0124; | |
2956 | ||
2957 | fC[3][0] = 0.005; | |
2958 | fC[3][1] = 0.005; | |
2959 | fC[3][2] = 1.0000; | |
2960 | fC[3][3] = 0.0640; | |
2961 | fC[3][4] = 0.0539; | |
2962 | ||
2963 | fC[4][0] = 0.005; | |
2964 | fC[4][1] = 0.005; | |
2965 | fC[4][2] = 1.0000; | |
2966 | fC[4][3] = 0.0923; | |
2967 | fC[4][4] = 0.0992; | |
2968 | ||
2969 | fC[5][0] = 0.005; | |
2970 | fC[5][1] = 0.005; | |
2971 | fC[5][2] = 1.0000; | |
2972 | fC[5][3] = 0.1202; | |
2973 | fC[5][4] = 0.1417; | |
2974 | ||
2975 | fC[6][0] = 0.005; | |
2976 | fC[6][1] = 0.005; | |
2977 | fC[6][2] = 1.0000; | |
2978 | fC[6][3] = 0.1413; | |
2979 | fC[6][4] = 0.1729; | |
2980 | ||
2981 | fC[7][0] = 0.005; | |
2982 | fC[7][1] = 0.005; | |
2983 | fC[7][2] = 1.0000; | |
2984 | fC[7][3] = 0.1705; | |
2985 | fC[7][4] = 0.1999; | |
2986 | ||
2987 | fC[8][0] = 0.005; | |
2988 | fC[8][1] = 0.005; | |
2989 | fC[8][2] = 1.0000; | |
2990 | fC[8][3] = 0.2103; | |
2991 | fC[8][4] = 0.2472; | |
2992 | ||
2993 | fC[9][0] = 0.005; | |
2994 | fC[9][1] = 0.005; | |
2995 | fC[9][2] = 1.0000; | |
2996 | fC[9][3] = 0.2373; | |
2997 | fC[9][4] = 0.2916; | |
2998 | ||
2999 | fC[10][0] = 0.005; | |
3000 | fC[10][1] = 0.005; | |
3001 | fC[10][2] = 1.0000; | |
3002 | fC[10][3] = 0.2824; | |
3003 | fC[10][4] = 0.3323; | |
3004 | ||
3005 | fC[11][0] = 0.005; | |
3006 | fC[11][1] = 0.005; | |
3007 | fC[11][2] = 1.0000; | |
3008 | fC[11][3] = 0.3046; | |
3009 | fC[11][4] = 0.3576; | |
3010 | ||
3011 | fC[12][0] = 0.005; | |
3012 | fC[12][1] = 0.005; | |
3013 | fC[12][2] = 1.0000; | |
3014 | fC[12][3] = 0.3585; | |
3015 | fC[12][4] = 0.4003; | |
3016 | ||
3017 | fC[13][0] = 0.005; | |
3018 | fC[13][1] = 0.005; | |
3019 | fC[13][2] = 1.0000; | |
3020 | fC[13][3] = 0.3461; | |
3021 | fC[13][4] = 0.3982; | |
3022 | ||
3023 | fC[14][0] = 0.005; | |
3024 | fC[14][1] = 0.005; | |
3025 | fC[14][2] = 1.0000; | |
3026 | fC[14][3] = 0.3362; | |
3027 | fC[14][4] = 0.3776; | |
3028 | ||
3029 | fC[15][0] = 0.005; | |
3030 | fC[15][1] = 0.005; | |
3031 | fC[15][2] = 1.0000; | |
3032 | fC[15][3] = 0.3071; | |
3033 | fC[15][4] = 0.3500; | |
3034 | ||
3035 | fC[16][0] = 0.005; | |
3036 | fC[16][1] = 0.005; | |
3037 | fC[16][2] = 1.0000; | |
3038 | fC[16][3] = 0.2914; | |
3039 | fC[16][4] = 0.3937; | |
3040 | ||
3041 | fC[17][0] = 0.005; | |
3042 | fC[17][1] = 0.005; | |
3043 | fC[17][2] = 1.0000; | |
3044 | fC[17][3] = 0.3727; | |
3045 | fC[17][4] = 0.3877; | |
3046 | } | |
3047 | // 80-100% | |
3048 | else{ | |
3049 | fC[0][0] = 0.005; | |
3050 | fC[0][1] = 0.005; | |
3051 | fC[0][2] = 1.0000; | |
3052 | fC[0][3] = 0.0010; | |
3053 | fC[0][4] = 0.0010; | |
3054 | ||
3055 | fC[1][0] = 0.005; | |
3056 | fC[1][1] = 0.005; | |
3057 | fC[1][2] = 1.0000; | |
3058 | fC[1][3] = 0.0060; | |
3059 | fC[1][4] = 0.0035; | |
3060 | ||
3061 | fC[2][0] = 0.005; | |
3062 | fC[2][1] = 0.005; | |
3063 | fC[2][2] = 1.0000; | |
3064 | fC[2][3] = 0.0323; | |
3065 | fC[2][4] = 0.0113; | |
3066 | ||
3067 | fC[3][0] = 0.005; | |
3068 | fC[3][1] = 0.005; | |
3069 | fC[3][2] = 1.0000; | |
3070 | fC[3][3] = 0.0609; | |
3071 | fC[3][4] = 0.0653; | |
3072 | ||
3073 | fC[4][0] = 0.005; | |
3074 | fC[4][1] = 0.005; | |
3075 | fC[4][2] = 1.0000; | |
3076 | fC[4][3] = 0.0922; | |
3077 | fC[4][4] = 0.1076; | |
3078 | ||
3079 | fC[5][0] = 0.005; | |
3080 | fC[5][1] = 0.005; | |
3081 | fC[5][2] = 1.0000; | |
3082 | fC[5][3] = 0.1096; | |
3083 | fC[5][4] = 0.1328; | |
3084 | ||
3085 | fC[6][0] = 0.005; | |
3086 | fC[6][1] = 0.005; | |
3087 | fC[6][2] = 1.0000; | |
3088 | fC[6][3] = 0.1495; | |
3089 | fC[6][4] = 0.1779; | |
3090 | ||
3091 | fC[7][0] = 0.005; | |
3092 | fC[7][1] = 0.005; | |
3093 | fC[7][2] = 1.0000; | |
3094 | fC[7][3] = 0.1519; | |
3095 | fC[7][4] = 0.1989; | |
3096 | ||
3097 | fC[8][0] = 0.005; | |
3098 | fC[8][1] = 0.005; | |
3099 | fC[8][2] = 1.0000; | |
3100 | fC[8][3] = 0.1817; | |
3101 | fC[8][4] = 0.2472; | |
3102 | ||
3103 | fC[9][0] = 0.005; | |
3104 | fC[9][1] = 0.005; | |
3105 | fC[9][2] = 1.0000; | |
3106 | fC[9][3] = 0.2429; | |
3107 | fC[9][4] = 0.2684; | |
3108 | ||
3109 | fC[10][0] = 0.005; | |
3110 | fC[10][1] = 0.005; | |
3111 | fC[10][2] = 1.0000; | |
3112 | fC[10][3] = 0.2760; | |
3113 | fC[10][4] = 0.3098; | |
3114 | ||
3115 | fC[11][0] = 0.005; | |
3116 | fC[11][1] = 0.005; | |
3117 | fC[11][2] = 1.0000; | |
3118 | fC[11][3] = 0.2673; | |
3119 | fC[11][4] = 0.3198; | |
3120 | ||
3121 | fC[12][0] = 0.005; | |
3122 | fC[12][1] = 0.005; | |
3123 | fC[12][2] = 1.0000; | |
3124 | fC[12][3] = 0.3165; | |
3125 | fC[12][4] = 0.3564; | |
3126 | ||
3127 | fC[13][0] = 0.005; | |
3128 | fC[13][1] = 0.005; | |
3129 | fC[13][2] = 1.0000; | |
3130 | fC[13][3] = 0.3526; | |
3131 | fC[13][4] = 0.3011; | |
3132 | ||
3133 | fC[14][0] = 0.005; | |
3134 | fC[14][1] = 0.005; | |
3135 | fC[14][2] = 1.0000; | |
3136 | fC[14][3] = 0.3788; | |
3137 | fC[14][4] = 0.3011; | |
3138 | ||
3139 | fC[15][0] = 0.005; | |
3140 | fC[15][1] = 0.005; | |
3141 | fC[15][2] = 1.0000; | |
3142 | fC[15][3] = 0.3788; | |
3143 | fC[15][4] = 0.3011; | |
3144 | ||
3145 | fC[16][0] = 0.005; | |
3146 | fC[16][1] = 0.005; | |
3147 | fC[16][2] = 1.0000; | |
3148 | fC[16][3] = 0.3788; | |
3149 | fC[16][4] = 0.3011; | |
3150 | ||
3151 | fC[17][0] = 0.005; | |
3152 | fC[17][1] = 0.005; | |
3153 | fC[17][2] = 1.0000; | |
3154 | fC[17][3] = 0.3788; | |
3155 | fC[17][4] = 0.3011; | |
3156 | } | |
3157 | ||
3158 | for(Int_t i=18;i<fgkPIDptBin;i++){ | |
3159 | fBinLimitPID[i] = 3.0 + 0.2 * (i-18); | |
3160 | fC[i][0] = fC[17][0]; | |
3161 | fC[i][1] = fC[17][1]; | |
3162 | fC[i][2] = fC[17][2]; | |
3163 | fC[i][3] = fC[17][3]; | |
3164 | fC[i][4] = fC[17][4]; | |
3165 | } | |
3166 | } | |
3167 | ||
3168 | //---------------------------------------------------------------// | |
3169 | Bool_t AliFlowTrackCuts::TPCTOFagree(const AliESDtrack *track) | |
3170 | { | |
3171 | Bool_t status = kFALSE; | |
3172 | ||
3173 | Float_t mass[5] = {5.10998909999999971e-04,1.05658000000000002e-01,1.39570000000000000e-01,4.93676999999999977e-01,9.38271999999999995e-01}; | |
3174 | ||
3175 | ||
3176 | Double_t exptimes[5]; | |
3177 | track->GetIntegratedTimes(exptimes); | |
3178 | ||
3179 | Float_t dedx = track->GetTPCsignal(); | |
3180 | ||
3181 | Float_t p = track->P(); | |
3182 | Float_t time = track->GetTOFsignal()- fESDpid.GetTOFResponse().GetStartTime(p); | |
3183 | Float_t tl = track->GetIntegratedLength(); | |
3184 | ||
3185 | Float_t betagammares = fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[4], mass[4]); | |
3186 | ||
3187 | Float_t betagamma1 = tl/(time-5 *betagammares) * 33.3564095198152043; | |
3188 | ||
3189 | // printf("betagamma1 = %f\n",betagamma1); | |
3190 | ||
3191 | if(betagamma1 < 0.1) betagamma1 = 0.1; | |
3192 | ||
3193 | if(betagamma1 < 0.99999) betagamma1 /= TMath::Sqrt(1-betagamma1*betagamma1); | |
3194 | else betagamma1 = 100; | |
3195 | ||
3196 | Float_t betagamma2 = tl/(time+5 *betagammares) * 33.3564095198152043; | |
3197 | // printf("betagamma2 = %f\n",betagamma2); | |
3198 | ||
3199 | if(betagamma2 < 0.1) betagamma2 = 0.1; | |
3200 | ||
3201 | if(betagamma2 < 0.99999) betagamma2 /= TMath::Sqrt(1-betagamma2*betagamma2); | |
3202 | else betagamma2 = 100; | |
3203 | ||
3204 | ||
3205 | Double_t ptpc[3]; | |
3206 | track->GetInnerPxPyPz(ptpc); | |
3207 | Float_t momtpc=TMath::Sqrt(ptpc[0]*ptpc[0] + ptpc[1]*ptpc[1] + ptpc[2]*ptpc[2]); | |
3208 | ||
3209 | for(Int_t i=0;i < 5;i++){ | |
3210 | Float_t resolutionTOF = fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[i], mass[i]); | |
3211 | if(TMath::Abs(exptimes[i] - time) < 5 * resolutionTOF){ | |
3212 | Float_t dedxExp = 0; | |
3213 | if(i==0) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kElectron); | |
3214 | else if(i==1) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kMuon); | |
3215 | else if(i==2) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kPion); | |
3216 | else if(i==3) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kKaon); | |
3217 | else if(i==4) dedxExp = fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kProton); | |
3218 | ||
3219 | Float_t resolutionTPC = 2; | |
3220 | if(i==0) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kElectron); | |
3221 | else if(i==1) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kMuon); | |
3222 | else if(i==2) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kPion); | |
3223 | else if(i==3) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kKaon); | |
3224 | else if(i==4) resolutionTPC = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kProton); | |
3225 | ||
3226 | if(TMath::Abs(dedx - dedxExp) < 3 * resolutionTPC){ | |
3227 | status = kTRUE; | |
3228 | } | |
3229 | } | |
3230 | } | |
3231 | ||
3232 | Float_t bb1 = fESDpid.GetTPCResponse().Bethe(betagamma1); | |
3233 | Float_t bb2 = fESDpid.GetTPCResponse().Bethe(betagamma2); | |
3234 | Float_t bbM = fESDpid.GetTPCResponse().Bethe((betagamma1+betagamma2)*0.5); | |
3235 | ||
3236 | ||
3237 | // status = kFALSE; | |
3238 | // for nuclei | |
3239 | Float_t resolutionTOFpr = fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[4], mass[4]); | |
3240 | Float_t resolutionTPCpr = fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kProton); | |
3241 | if(TMath::Abs(dedx-bb1) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){ | |
3242 | status = kTRUE; | |
3243 | } | |
3244 | else if(TMath::Abs(dedx-bb2) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){ | |
3245 | status = kTRUE; | |
3246 | } | |
3247 | else if(TMath::Abs(dedx-bbM) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){ | |
3248 | status = kTRUE; | |
3249 | } | |
3250 | ||
3251 | return status; | |
3252 | } | |
3253 | // end part added by F. Noferini | |
3254 | //----------------------------------------------------------------------- | |
3255 | ||
3256 | //----------------------------------------------------------------------- | |
3257 | const char* AliFlowTrackCuts::PIDsourceName(PIDsource s) | |
3258 | { | |
3259 | //get the name of the particle id source | |
3260 | switch (s) | |
3261 | { | |
3262 | case kTPCdedx: | |
3263 | return "TPCdedx"; | |
3264 | case kTOFbeta: | |
3265 | return "TOFbeta"; | |
3266 | case kTPCpid: | |
3267 | return "TPCpid"; | |
3268 | case kTOFpid: | |
3269 | return "TOFpid"; | |
3270 | case kTOFbayesian: | |
3271 | return "TOFbayesianPID"; | |
3272 | case kTOFbetaSimple: | |
3273 | return "TOFbetaSimple"; | |
3274 | default: | |
3275 | return "NOPID"; | |
3276 | } | |
3277 | } | |
3278 | ||
3279 | //----------------------------------------------------------------------- | |
3280 | const char* AliFlowTrackCuts::GetParamTypeName(trackParameterType type) | |
3281 | { | |
3282 | //return the name of the selected parameter type | |
3283 | switch (type) | |
3284 | { | |
3285 | case kMC: | |
3286 | return "MC"; | |
3287 | case kGlobal: | |
3288 | return "Global"; | |
3289 | case kTPCstandalone: | |
3290 | return "TPCstandalone"; | |
3291 | case kSPDtracklet: | |
3292 | return "SPDtracklets"; | |
3293 | case kPMD: | |
3294 | return "PMD"; | |
3295 | case kV0: | |
3296 | return "V0"; | |
3297 | default: | |
3298 | return "unknown"; | |
3299 | } | |
3300 | } | |
3301 | ||
3302 | //----------------------------------------------------------------------- | |
3303 | Bool_t AliFlowTrackCuts::PassesPMDcuts(AliESDPmdTrack* track ) | |
3304 | { | |
3305 | //check PMD specific cuts | |
3306 | //clean up from last iteration, and init label | |
3307 | Int_t det = track->GetDetector(); | |
3308 | //Int_t smn = track->GetSmn(); | |
3309 | Float_t clsX = track->GetClusterX(); | |
3310 | Float_t clsY = track->GetClusterY(); | |
3311 | Float_t clsZ = track->GetClusterZ(); | |
3312 | Float_t ncell = track->GetClusterCells(); | |
3313 | Float_t adc = track->GetClusterADC(); | |
3314 | ||
3315 | fTrack = NULL; | |
3316 | fMCparticle=NULL; | |
3317 | fTrackLabel=-1; | |
3318 | ||
3319 | fTrackEta = GetPmdEta(clsX,clsY,clsZ); | |
3320 | fTrackPhi = GetPmdPhi(clsX,clsY); | |
3321 | fTrackWeight = 1.0; | |
3322 | ||
3323 | Bool_t pass=kTRUE; | |
3324 | if (fCutEta) {if ( fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) pass = kFALSE;} | |
3325 | if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) pass = kFALSE;} | |
3326 | if (fCutPmdDet) {if(det != fPmdDet) pass = kFALSE;} | |
3327 | if (fCutPmdAdc) {if(adc < fPmdAdc) pass = kFALSE;} | |
3328 | if (fCutPmdNcell) {if(ncell < fPmdNcell) pass = kFALSE;} | |
3329 | ||
3330 | return pass; | |
3331 | } | |
3332 | ||
3333 | //----------------------------------------------------------------------- | |
3334 | Bool_t AliFlowTrackCuts::PassesV0cuts(AliESDVZERO* vzero, Int_t id) | |
3335 | { | |
3336 | //check V0 cuts | |
3337 | ||
3338 | //clean up from last iter | |
3339 | fTrack = NULL; | |
3340 | fMCparticle=NULL; | |
3341 | fTrackLabel=-1; | |
3342 | ||
3343 | fTrackPhi = TMath::PiOver4()*(0.5+id%8); | |
3344 | if(id<32) | |
3345 | fTrackEta = -3.45+0.5*(id/8); // taken from PPR | |
3346 | else | |
3347 | fTrackEta = +4.8-0.5*((id/8)-4); // taken from PPR | |
3348 | fTrackWeight = vzero->GetMultiplicity(id); // not corrected yet: we should use AliESDUtils | |
3349 | ||
3350 | Bool_t pass=kTRUE; | |
3351 | if (fCutEta) {if ( fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) pass = kFALSE;} | |
3352 | if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) pass = kFALSE;} | |
3353 | ||
3354 | return pass; | |
3355 | } | |
3356 | ||
3357 | //----------------------------------------------------------------------------// | |
3358 | Double_t AliFlowTrackCuts::GetPmdEta(Float_t xPos, Float_t yPos, Float_t zPos) | |
3359 | { | |
3360 | Float_t rpxpy, theta, eta; | |
3361 | rpxpy = TMath::Sqrt(xPos*xPos + yPos*yPos); | |
3362 | theta = TMath::ATan2(rpxpy,zPos); | |
3363 | eta = -TMath::Log(TMath::Tan(0.5*theta)); | |
3364 | return eta; | |
3365 | } | |
3366 | ||
3367 | //--------------------------------------------------------------------------// | |
3368 | Double_t AliFlowTrackCuts::GetPmdPhi(Float_t xPos, Float_t yPos) | |
3369 | { | |
3370 | Float_t pybypx, phi = 0., phi1; | |
3371 | if(xPos==0) | |
3372 | { | |
3373 | if(yPos>0) phi = 90.; | |
3374 | if(yPos<0) phi = 270.; | |
3375 | } | |
3376 | if(xPos != 0) | |
3377 | { | |
3378 | pybypx = yPos/xPos; | |
3379 | if(pybypx < 0) pybypx = - pybypx; | |
3380 | phi1 = TMath::ATan(pybypx)*180./3.14159; | |
3381 | ||
3382 | if(xPos > 0 && yPos > 0) phi = phi1; // 1st Quadrant | |
3383 | if(xPos < 0 && yPos > 0) phi = 180 - phi1; // 2nd Quadrant | |
3384 | if(xPos < 0 && yPos < 0) phi = 180 + phi1; // 3rd Quadrant | |
3385 | if(xPos > 0 && yPos < 0) phi = 360 - phi1; // 4th Quadrant | |
3386 | ||
3387 | } | |
3388 | phi = phi*3.14159/180.; | |
3389 | return phi; | |
3390 | } | |
3391 | ||
3392 | //---------------------------------------------------------------// | |
3393 | void AliFlowTrackCuts::Browse(TBrowser* b) | |
3394 | { | |
3395 | //some browsing capabilities | |
3396 | if (fQA) b->Add(fQA); | |
3397 | } | |
3398 | ||
3399 | //---------------------------------------------------------------// | |
3400 | Long64_t AliFlowTrackCuts::Merge(TCollection* list) | |
3401 | { | |
3402 | //merge | |
3403 | Int_t number=0; | |
3404 | AliFlowTrackCuts* obj; | |
3405 | if (!list) return 0; | |
3406 | if (list->GetEntries()<1) return 0; | |
3407 | TIter next(list); | |
3408 | while ( (obj = dynamic_cast<AliFlowTrackCuts*>(next())) ) | |
3409 | { | |
3410 | if (obj==this) continue; | |
3411 | TList listwrapper; | |
3412 | listwrapper.Add(obj->GetQA()); | |
3413 | fQA->Merge(&listwrapper); | |
3414 | number++; | |
3415 | } | |
3416 | return number; | |
3417 | } | |
3418 |