| daf66719 |
1 | /************************************************************************** |
| 2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * |
| 3 | * * |
| 4 | * Author: The ALICE Off-line Project. * |
| 5 | * Contributors are mentioned in the code where appropriate. * |
| 6 | * * |
| 7 | * Permission to use, copy, modify and distribute this software and its * |
| 8 | * documentation strictly for non-commercial purposes is hereby granted * |
| 9 | * without fee, provided that the above copyright notice appears in all * |
| 10 | * copies and that both the copyright notice and this permission notice * |
| 11 | * appear in the supporting documentation. The authors make no claims * |
| 12 | * about the suitability of this software for any purpose. It is * |
| 13 | * provided "as is" without express or implied warranty. * |
| 14 | **************************************************************************/ |
| 15 | |
| 16 | /* $Id$ */ |
| 17 | |
| 18 | // AliFlowTrackCuts: |
| 19 | // ESD track cuts for flow framework |
| 20 | // |
| 21 | // origin: Mikolaj Krzewicki (mikolaj.krzewicki@cern.ch) |
| 5559ce24 |
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. |
| daf66719 |
36 | |
| 37 | #include <limits.h> |
| 38 | #include <float.h> |
| 32b846cd |
39 | #include <TMatrix.h> |
| 875ee12a |
40 | #include "TMCProcess.h" |
| 9a0783cc |
41 | #include "TParticle.h" |
| 1a80f9f6 |
42 | #include "TH2F.h" |
| 9a0783cc |
43 | #include "AliStack.h" |
| 499fe731 |
44 | #include "TBrowser.h" |
| daf66719 |
45 | #include "AliMCEvent.h" |
| 9a0783cc |
46 | #include "AliESDEvent.h" |
| daf66719 |
47 | #include "AliVParticle.h" |
| 48 | #include "AliMCParticle.h" |
| 49 | #include "AliESDtrack.h" |
| 12b2b8bc |
50 | #include "AliMultiplicity.h" |
| daf66719 |
51 | #include "AliAODTrack.h" |
| 52 | #include "AliFlowTrack.h" |
| 53 | #include "AliFlowTrackCuts.h" |
| 54 | #include "AliLog.h" |
| 32b846cd |
55 | #include "AliESDpid.h" |
| d148af7e |
56 | #include "AliESDPmdTrack.h" |
| 22289738 |
57 | #include "AliESDVZERO.h" |
| daf66719 |
58 | |
| 59 | ClassImp(AliFlowTrackCuts) |
| 60 | |
| 61 | //----------------------------------------------------------------------- |
| 62 | AliFlowTrackCuts::AliFlowTrackCuts(): |
| 441ea1cf |
63 | AliFlowTrackSimpleCuts(), |
| 64 | fAliESDtrackCuts(NULL), |
| 65 | fQA(NULL), |
| 66 | fCutMC(kFALSE), |
| f21bdf48 |
67 | fCutMChasTrackReferences(kFALSE), |
| 441ea1cf |
68 | fCutMCprocessType(kFALSE), |
| 69 | fMCprocessType(kPNoProcess), |
| 70 | fCutMCPID(kFALSE), |
| 71 | fMCPID(0), |
| a14b8f3c |
72 | fIgnoreSignInMCPID(kFALSE), |
| 441ea1cf |
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), |
| 42655d16 |
90 | fCutNClustersITS(kFALSE), |
| 91 | fNClustersITSMax(INT_MAX), |
| 92 | fNClustersITSMin(INT_MIN), |
| 5ba02b32 |
93 | fUseAODFilterBit(kFALSE), |
| 94 | fAODFilterBit(0), |
| a63303bd |
95 | fCutDCAToVertexXY(kFALSE), |
| 96 | fCutDCAToVertexZ(kFALSE), |
| 2b1eaa10 |
97 | fCutMinimalTPCdedx(kFALSE), |
| 98 | fMinimalTPCdedx(0.), |
| 1a80f9f6 |
99 | fCutPmdDet(kFALSE), |
| 100 | fPmdDet(0), |
| 101 | fCutPmdAdc(kFALSE), |
| 102 | fPmdAdc(0.), |
| 103 | fCutPmdNcell(kFALSE), |
| 104 | fPmdNcell(0.), |
| 441ea1cf |
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(), |
| aab6527a |
116 | fESDpid(), |
| 2b1eaa10 |
117 | fPIDsource(kTOFpid), |
| 441ea1cf |
118 | fTPCpidCuts(NULL), |
| 119 | fTOFpidCuts(NULL), |
| a14b8f3c |
120 | fParticleID(AliPID::kUnknown), |
| 499fe731 |
121 | fParticleProbability(.9), |
| 875ee12a |
122 | fAllowTOFmismatchFlag(kFALSE), |
| 123 | fRequireStrictTOFTPCagreement(kFALSE) |
| 441ea1cf |
124 | { |
| 125 | //io constructor |
| 5104aa35 |
126 | for ( Int_t i=0; i<5; i++ ) { fProbBayes[i]=0.0; } |
| 422c61c7 |
127 | SetPriors(); //init arrays |
| 441ea1cf |
128 | } |
| 129 | |
| 130 | //----------------------------------------------------------------------- |
| 131 | AliFlowTrackCuts::AliFlowTrackCuts(const char* name): |
| daf66719 |
132 | AliFlowTrackSimpleCuts(), |
| 1a80f9f6 |
133 | fAliESDtrackCuts(NULL), |
| a1c43d26 |
134 | fQA(NULL), |
| 1ff4bda1 |
135 | fCutMC(kFALSE), |
| f21bdf48 |
136 | fCutMChasTrackReferences(kFALSE), |
| daf66719 |
137 | fCutMCprocessType(kFALSE), |
| 138 | fMCprocessType(kPNoProcess), |
| 139 | fCutMCPID(kFALSE), |
| 140 | fMCPID(0), |
| a14b8f3c |
141 | fIgnoreSignInMCPID(kFALSE), |
| daf66719 |
142 | fCutMCisPrimary(kFALSE), |
| 441ea1cf |
143 | fRequireTransportBitForPrimaries(kTRUE), |
| daf66719 |
144 | fMCisPrimary(kFALSE), |
| 957517fa |
145 | fRequireCharge(kFALSE), |
| 127a5825 |
146 | fFakesAreOK(kTRUE), |
| 9a0783cc |
147 | fCutSPDtrackletDeltaPhi(kFALSE), |
| 148 | fSPDtrackletDeltaPhiMax(FLT_MAX), |
| 149 | fSPDtrackletDeltaPhiMin(-FLT_MAX), |
| 1ff4bda1 |
150 | fIgnoreTPCzRange(kFALSE), |
| 151 | fIgnoreTPCzRangeMax(FLT_MAX), |
| 152 | fIgnoreTPCzRangeMin(-FLT_MAX), |
| 2948ac5a |
153 | fCutChi2PerClusterTPC(kFALSE), |
| 154 | fMaxChi2PerClusterTPC(FLT_MAX), |
| 155 | fMinChi2PerClusterTPC(-FLT_MAX), |
| 32b846cd |
156 | fCutNClustersTPC(kFALSE), |
| 157 | fNClustersTPCMax(INT_MAX), |
| 158 | fNClustersTPCMin(INT_MIN), |
| 42655d16 |
159 | fCutNClustersITS(kFALSE), |
| 160 | fNClustersITSMax(INT_MAX), |
| 5ba02b32 |
161 | fNClustersITSMin(INT_MIN), |
| 162 | fUseAODFilterBit(kFALSE), |
| 163 | fAODFilterBit(0), |
| a63303bd |
164 | fCutDCAToVertexXY(kFALSE), |
| 165 | fCutDCAToVertexZ(kFALSE), |
| 2b1eaa10 |
166 | fCutMinimalTPCdedx(kFALSE), |
| 167 | fMinimalTPCdedx(0.), |
| 1a80f9f6 |
168 | fCutPmdDet(kFALSE), |
| 169 | fPmdDet(0), |
| 170 | fCutPmdAdc(kFALSE), |
| 171 | fPmdAdc(0.), |
| 172 | fCutPmdNcell(kFALSE), |
| 173 | fPmdNcell(0.), |
| 12b2b8bc |
174 | fParamType(kGlobal), |
| daf66719 |
175 | fParamMix(kPure), |
| daf66719 |
176 | fTrack(NULL), |
| 12b2b8bc |
177 | fTrackPhi(0.), |
| 178 | fTrackEta(0.), |
| 179 | fTrackWeight(0.), |
| 127a5825 |
180 | fTrackLabel(INT_MIN), |
| 957517fa |
181 | fMCevent(NULL), |
| 9a0783cc |
182 | fMCparticle(NULL), |
| 1ff4bda1 |
183 | fEvent(NULL), |
| 32b846cd |
184 | fTPCtrack(), |
| aab6527a |
185 | fESDpid(), |
| 2b1eaa10 |
186 | fPIDsource(kTOFpid), |
| 32b846cd |
187 | fTPCpidCuts(NULL), |
| 188 | fTOFpidCuts(NULL), |
| a14b8f3c |
189 | fParticleID(AliPID::kUnknown), |
| 499fe731 |
190 | fParticleProbability(.9), |
| 875ee12a |
191 | fAllowTOFmismatchFlag(kFALSE), |
| 192 | fRequireStrictTOFTPCagreement(kFALSE) |
| daf66719 |
193 | { |
| 194 | //constructor |
| 441ea1cf |
195 | SetName(name); |
| 196 | SetTitle("AliFlowTrackCuts"); |
| aab6527a |
197 | fESDpid.GetTPCResponse().SetBetheBlochParameters( 0.0283086, |
| 198 | 2.63394e+01, |
| 199 | 5.04114e-11, |
| 200 | 2.12543e+00, |
| 201 | 4.88663e+00 ); |
| 5104aa35 |
202 | for ( Int_t i=0; i<5; i++ ) { fProbBayes[i]=0.0; } |
| 422c61c7 |
203 | SetPriors(); //init arrays |
| 1a80f9f6 |
204 | |
| daf66719 |
205 | } |
| 206 | |
| 207 | //----------------------------------------------------------------------- |
| ee242db3 |
208 | AliFlowTrackCuts::AliFlowTrackCuts(const AliFlowTrackCuts& that): |
| 209 | AliFlowTrackSimpleCuts(that), |
| 441ea1cf |
210 | fAliESDtrackCuts(NULL), |
| a1c43d26 |
211 | fQA(NULL), |
| 1ff4bda1 |
212 | fCutMC(that.fCutMC), |
| f21bdf48 |
213 | fCutMChasTrackReferences(that.fCutMChasTrackReferences), |
| ee242db3 |
214 | fCutMCprocessType(that.fCutMCprocessType), |
| 215 | fMCprocessType(that.fMCprocessType), |
| 216 | fCutMCPID(that.fCutMCPID), |
| 217 | fMCPID(that.fMCPID), |
| a14b8f3c |
218 | fIgnoreSignInMCPID(that.fIgnoreSignInMCPID), |
| ee242db3 |
219 | fCutMCisPrimary(that.fCutMCisPrimary), |
| 441ea1cf |
220 | fRequireTransportBitForPrimaries(that.fRequireTransportBitForPrimaries), |
| ee242db3 |
221 | fMCisPrimary(that.fMCisPrimary), |
| 222 | fRequireCharge(that.fRequireCharge), |
| 223 | fFakesAreOK(that.fFakesAreOK), |
| 224 | fCutSPDtrackletDeltaPhi(that.fCutSPDtrackletDeltaPhi), |
| 225 | fSPDtrackletDeltaPhiMax(that.fSPDtrackletDeltaPhiMax), |
| 226 | fSPDtrackletDeltaPhiMin(that.fSPDtrackletDeltaPhiMin), |
| 1ff4bda1 |
227 | fIgnoreTPCzRange(that.fIgnoreTPCzRange), |
| 228 | fIgnoreTPCzRangeMax(that.fIgnoreTPCzRangeMax), |
| 229 | fIgnoreTPCzRangeMin(that.fIgnoreTPCzRangeMin), |
| 2948ac5a |
230 | fCutChi2PerClusterTPC(that.fCutChi2PerClusterTPC), |
| 231 | fMaxChi2PerClusterTPC(that.fMaxChi2PerClusterTPC), |
| 232 | fMinChi2PerClusterTPC(that.fMinChi2PerClusterTPC), |
| 32b846cd |
233 | fCutNClustersTPC(that.fCutNClustersTPC), |
| 234 | fNClustersTPCMax(that.fNClustersTPCMax), |
| 235 | fNClustersTPCMin(that.fNClustersTPCMin), |
| 42655d16 |
236 | fCutNClustersITS(that.fCutNClustersITS), |
| 237 | fNClustersITSMax(that.fNClustersITSMax), |
| 238 | fNClustersITSMin(that.fNClustersITSMin), |
| 5ba02b32 |
239 | fUseAODFilterBit(that.fUseAODFilterBit), |
| 240 | fAODFilterBit(that.fAODFilterBit), |
| a63303bd |
241 | fCutDCAToVertexXY(that.fCutDCAToVertexXY), |
| 242 | fCutDCAToVertexZ(that.fCutDCAToVertexZ), |
| 2b1eaa10 |
243 | fCutMinimalTPCdedx(that.fCutMinimalTPCdedx), |
| 244 | fMinimalTPCdedx(that.fMinimalTPCdedx), |
| 1a80f9f6 |
245 | fCutPmdDet(that.fCutPmdDet), |
| 246 | fPmdDet(that.fPmdDet), |
| 247 | fCutPmdAdc(that.fCutPmdAdc), |
| 248 | fPmdAdc(that.fPmdAdc), |
| 249 | fCutPmdNcell(that.fCutPmdNcell), |
| 250 | fPmdNcell(that.fPmdNcell), |
| ee242db3 |
251 | fParamType(that.fParamType), |
| 252 | fParamMix(that.fParamMix), |
| daf66719 |
253 | fTrack(NULL), |
| ee242db3 |
254 | fTrackPhi(0.), |
| 255 | fTrackEta(0.), |
| 256 | fTrackWeight(0.), |
| 127a5825 |
257 | fTrackLabel(INT_MIN), |
| 957517fa |
258 | fMCevent(NULL), |
| 9a0783cc |
259 | fMCparticle(NULL), |
| 1ff4bda1 |
260 | fEvent(NULL), |
| 32b846cd |
261 | fTPCtrack(), |
| 262 | fESDpid(that.fESDpid), |
| 263 | fPIDsource(that.fPIDsource), |
| 264 | fTPCpidCuts(NULL), |
| 265 | fTOFpidCuts(NULL), |
| 2b1eaa10 |
266 | fParticleID(that.fParticleID), |
| 499fe731 |
267 | fParticleProbability(that.fParticleProbability), |
| 875ee12a |
268 | fAllowTOFmismatchFlag(that.fAllowTOFmismatchFlag), |
| 269 | fRequireStrictTOFTPCagreement(that.fRequireStrictTOFTPCagreement) |
| daf66719 |
270 | { |
| 271 | //copy constructor |
| 32b846cd |
272 | if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts)); |
| 273 | if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts)); |
| 441ea1cf |
274 | if (that.fAliESDtrackCuts) fAliESDtrackCuts = new AliESDtrackCuts(*(that.fAliESDtrackCuts)); |
| 5104aa35 |
275 | memcpy(fProbBayes,that.fProbBayes,sizeof(fProbBayes)); |
| 422c61c7 |
276 | SetPriors(); //init arrays |
| 1a80f9f6 |
277 | if (that.fQA) DefineHistograms(); |
| daf66719 |
278 | } |
| 279 | |
| 280 | //----------------------------------------------------------------------- |
| ee242db3 |
281 | AliFlowTrackCuts& AliFlowTrackCuts::operator=(const AliFlowTrackCuts& that) |
| daf66719 |
282 | { |
| 283 | //assignment |
| cdc20344 |
284 | if (this==&that) return *this; |
| 285 | |
| ee242db3 |
286 | AliFlowTrackSimpleCuts::operator=(that); |
| 1a80f9f6 |
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();} |
| 1ff4bda1 |
294 | fCutMC=that.fCutMC; |
| f21bdf48 |
295 | fCutMChasTrackReferences=that.fCutMChasTrackReferences; |
| ee242db3 |
296 | fCutMCprocessType=that.fCutMCprocessType; |
| 297 | fMCprocessType=that.fMCprocessType; |
| 298 | fCutMCPID=that.fCutMCPID; |
| 299 | fMCPID=that.fMCPID; |
| a14b8f3c |
300 | fIgnoreSignInMCPID=that.fIgnoreSignInMCPID, |
| ee242db3 |
301 | fCutMCisPrimary=that.fCutMCisPrimary; |
| 441ea1cf |
302 | fRequireTransportBitForPrimaries=that.fRequireTransportBitForPrimaries; |
| ee242db3 |
303 | fMCisPrimary=that.fMCisPrimary; |
| 304 | fRequireCharge=that.fRequireCharge; |
| 305 | fFakesAreOK=that.fFakesAreOK; |
| 306 | fCutSPDtrackletDeltaPhi=that.fCutSPDtrackletDeltaPhi; |
| 307 | fSPDtrackletDeltaPhiMax=that.fSPDtrackletDeltaPhiMax; |
| 308 | fSPDtrackletDeltaPhiMin=that.fSPDtrackletDeltaPhiMin; |
| 1ff4bda1 |
309 | fIgnoreTPCzRange=that.fIgnoreTPCzRange; |
| 310 | fIgnoreTPCzRangeMax=that.fIgnoreTPCzRangeMax; |
| 311 | fIgnoreTPCzRangeMin=that.fIgnoreTPCzRangeMin; |
| 2948ac5a |
312 | fCutChi2PerClusterTPC=that.fCutChi2PerClusterTPC; |
| 313 | fMaxChi2PerClusterTPC=that.fMaxChi2PerClusterTPC; |
| 314 | fMinChi2PerClusterTPC=that.fMinChi2PerClusterTPC; |
| 32b846cd |
315 | fCutNClustersTPC=that.fCutNClustersTPC; |
| 316 | fNClustersTPCMax=that.fNClustersTPCMax; |
| 317 | fNClustersTPCMin=that.fNClustersTPCMin; |
| 42655d16 |
318 | fCutNClustersITS=that.fCutNClustersITS; |
| 319 | fNClustersITSMax=that.fNClustersITSMax; |
| 320 | fNClustersITSMin=that.fNClustersITSMin; |
| a63303bd |
321 | fUseAODFilterBit=that.fUseAODFilterBit; |
| 322 | fAODFilterBit=that.fAODFilterBit; |
| 323 | fCutDCAToVertexXY=that.fCutDCAToVertexXY; |
| 324 | fCutDCAToVertexZ=that.fCutDCAToVertexZ; |
| 2b1eaa10 |
325 | fCutMinimalTPCdedx=that.fCutMinimalTPCdedx; |
| 326 | fMinimalTPCdedx=that.fMinimalTPCdedx; |
| 1a80f9f6 |
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 | |
| ee242db3 |
334 | fParamType=that.fParamType; |
| 335 | fParamMix=that.fParamMix; |
| daf66719 |
336 | |
| daf66719 |
337 | fTrack=NULL; |
| 1a80f9f6 |
338 | fTrackEta=0.; |
| ee242db3 |
339 | fTrackPhi=0.; |
| 340 | fTrackWeight=0.; |
| 127a5825 |
341 | fTrackLabel=INT_MIN; |
| 957517fa |
342 | fMCevent=NULL; |
| daf66719 |
343 | fMCparticle=NULL; |
| 9a0783cc |
344 | fEvent=NULL; |
| daf66719 |
345 | |
| 32b846cd |
346 | fESDpid = that.fESDpid; |
| 347 | fPIDsource = that.fPIDsource; |
| 348 | |
| cdc20344 |
349 | delete fTPCpidCuts; |
| 350 | delete fTOFpidCuts; |
| 32b846cd |
351 | if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts)); |
| 352 | if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts)); |
| 32b846cd |
353 | |
| 2b1eaa10 |
354 | fParticleID=that.fParticleID; |
| 355 | fParticleProbability=that.fParticleProbability; |
| 875ee12a |
356 | fAllowTOFmismatchFlag=that.fAllowTOFmismatchFlag; |
| 357 | fRequireStrictTOFTPCagreement=that.fRequireStrictTOFTPCagreement; |
| 5104aa35 |
358 | memcpy(fProbBayes,that.fProbBayes,sizeof(fProbBayes)); |
| 32b846cd |
359 | |
| daf66719 |
360 | return *this; |
| 361 | } |
| 362 | |
| 363 | //----------------------------------------------------------------------- |
| 364 | AliFlowTrackCuts::~AliFlowTrackCuts() |
| 365 | { |
| 366 | //dtor |
| daf66719 |
367 | delete fAliESDtrackCuts; |
| 32b846cd |
368 | delete fTPCpidCuts; |
| 369 | delete fTOFpidCuts; |
| 499fe731 |
370 | if (fQA) { fQA->SetOwner(); fQA->Delete(); delete fQA; } |
| daf66719 |
371 | } |
| 372 | |
| aab6527a |
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 | |
| daf66719 |
412 | //----------------------------------------------------------------------- |
| 12b2b8bc |
413 | Bool_t AliFlowTrackCuts::IsSelected(TObject* obj, Int_t id) |
| daf66719 |
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); |
| 12b2b8bc |
420 | AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj); |
| 421 | if (tracklets) return PassesCuts(tracklets,id); |
| d148af7e |
422 | AliESDPmdTrack* pmdtrack = dynamic_cast<AliESDPmdTrack*>(obj); |
| 423 | if (pmdtrack) return PassesPMDcuts(pmdtrack); |
| 22289738 |
424 | AliESDVZERO* esdvzero = dynamic_cast<AliESDVZERO*>(obj); |
| 425 | if (esdvzero) return PassesV0cuts(esdvzero,id); |
| daf66719 |
426 | return kFALSE; //default when passed wrong type of object |
| 427 | } |
| 428 | |
| 1ff4bda1 |
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 | |
| daf66719 |
449 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
450 | Bool_t AliFlowTrackCuts::PassesCuts(const AliFlowTrackSimple* track) |
| daf66719 |
451 | { |
| 452 | //check cuts on a flowtracksimple |
| 5559ce24 |
453 | |
| 454 | //clean up from last iteration |
| 1ff4bda1 |
455 | fTrack = NULL; |
| daf66719 |
456 | return AliFlowTrackSimpleCuts::PassesCuts(track); |
| 457 | } |
| 458 | |
| 12b2b8bc |
459 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
460 | Bool_t AliFlowTrackCuts::PassesCuts(const AliMultiplicity* tracklet, Int_t id) |
| 12b2b8bc |
461 | { |
| 462 | //check cuts on a tracklets |
| 463 | |
| 9a0783cc |
464 | //clean up from last iteration, and init label |
| 1ff4bda1 |
465 | fTrack = NULL; |
| 12b2b8bc |
466 | fMCparticle=NULL; |
| 9a0783cc |
467 | fTrackLabel=-1; |
| 12b2b8bc |
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 |
| 9a0783cc |
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); |
| d0471ea0 |
480 | //if possible get label and mcparticle |
| 9a0783cc |
481 | fTrackLabel = (label0==label1)?tracklet->GetLabel(id,1):-1; |
| 7afa829c |
482 | if (!fFakesAreOK && fTrackLabel<0) return kFALSE; |
| d0471ea0 |
483 | if (fTrackLabel>=0 && fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel)); |
| 484 | //check MC cuts |
| 1ff4bda1 |
485 | if (fCutMC && !PassesMCcuts()) return kFALSE; |
| 12b2b8bc |
486 | return kTRUE; |
| 487 | } |
| 488 | |
| 489 | //----------------------------------------------------------------------- |
| 1ff4bda1 |
490 | Bool_t AliFlowTrackCuts::PassesMCcuts(AliMCEvent* mcEvent, Int_t label) |
| 12b2b8bc |
491 | { |
| 492 | //check the MC info |
| 1ff4bda1 |
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;} |
| 12b2b8bc |
497 | |
| 498 | if (fCutMCisPrimary) |
| 499 | { |
| 441ea1cf |
500 | if (IsPhysicalPrimary(mcEvent,label,fRequireTransportBitForPrimaries) != fMCisPrimary) return kFALSE; |
| 12b2b8bc |
501 | } |
| 502 | if (fCutMCPID) |
| 503 | { |
| 1ff4bda1 |
504 | Int_t pdgCode = mcparticle->PdgCode(); |
| a14b8f3c |
505 | if (fIgnoreSignInMCPID) |
| 4cbcbead |
506 | { |
| 507 | if (TMath::Abs(fMCPID) != TMath::Abs(pdgCode)) return kFALSE; |
| 508 | } |
| 509 | else |
| 510 | { |
| 511 | if (fMCPID != pdgCode) return kFALSE; |
| 512 | } |
| 12b2b8bc |
513 | } |
| 514 | if ( fCutMCprocessType ) |
| 515 | { |
| 1ff4bda1 |
516 | TParticle* particle = mcparticle->Particle(); |
| 12b2b8bc |
517 | Int_t processID = particle->GetUniqueID(); |
| 518 | if (processID != fMCprocessType ) return kFALSE; |
| 519 | } |
| f21bdf48 |
520 | if (fCutMChasTrackReferences) |
| 521 | { |
| 522 | if (mcparticle->GetNumberOfTrackReferences()<1) return kFALSE; |
| 523 | } |
| 12b2b8bc |
524 | return kTRUE; |
| 525 | } |
| 1a80f9f6 |
526 | |
| 1ff4bda1 |
527 | //----------------------------------------------------------------------- |
| 528 | Bool_t AliFlowTrackCuts::PassesMCcuts() |
| 529 | { |
| 1a80f9f6 |
530 | //check MC info |
| 1ff4bda1 |
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 | } |
| 12b2b8bc |
536 | |
| daf66719 |
537 | //----------------------------------------------------------------------- |
| 538 | Bool_t AliFlowTrackCuts::PassesCuts(AliVParticle* vparticle) |
| 539 | { |
| 540 | //check cuts for an ESD vparticle |
| 541 | |
| 127a5825 |
542 | //////////////////////////////////////////////////////////////// |
| 543 | // start by preparing the track parameters to cut on ////////// |
| 544 | //////////////////////////////////////////////////////////////// |
| 5559ce24 |
545 | //clean up from last iteration |
| 1ff4bda1 |
546 | fTrack=NULL; |
| 5559ce24 |
547 | |
| 957517fa |
548 | //get the label and the mc particle |
| 127a5825 |
549 | fTrackLabel = (fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel(); |
| 550 | if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel)); |
| daf66719 |
551 | else fMCparticle=NULL; |
| 552 | |
| 957517fa |
553 | Bool_t isMCparticle = kFALSE; //some things are different for MC particles, check! |
| daf66719 |
554 | AliESDtrack* esdTrack = dynamic_cast<AliESDtrack*>(vparticle); |
| 42655d16 |
555 | AliAODTrack* aodTrack = NULL; |
| daf66719 |
556 | if (esdTrack) |
| 7d27a354 |
557 | { |
| 42655d16 |
558 | //for an ESD track we do some magic sometimes like constructing TPC only parameters |
| 559 | //or doing some hybrid, handle that here |
| daf66719 |
560 | HandleESDtrack(esdTrack); |
| 7d27a354 |
561 | } |
| daf66719 |
562 | else |
| 957517fa |
563 | { |
| daf66719 |
564 | HandleVParticle(vparticle); |
| 957517fa |
565 | //now check if produced particle is MC |
| 566 | isMCparticle = (dynamic_cast<AliMCParticle*>(fTrack))!=NULL; |
| 42655d16 |
567 | aodTrack = dynamic_cast<AliAODTrack*>(vparticle); //keep the additional dynamic cast out of the way for ESDs |
| 957517fa |
568 | } |
| 127a5825 |
569 | //////////////////////////////////////////////////////////////// |
| 570 | //////////////////////////////////////////////////////////////// |
| 571 | |
| 1ff4bda1 |
572 | if (!fTrack) return kFALSE; |
| 42655d16 |
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); |
| 2948ac5a |
575 | |
| 924b02b0 |
576 | Bool_t pass=kTRUE; |
| 9a0783cc |
577 | //check the common cuts for the current particle fTrack (MC,AOD,ESD) |
| 32b846cd |
578 | Double_t pt = fTrack->Pt(); |
| f21bdf48 |
579 | Double_t p = fTrack->P(); |
| 7afa829c |
580 | if (!fFakesAreOK) {if (fTrackLabel<0) pass=kFALSE;} |
| 32b846cd |
581 | if (fCutPt) {if (pt < fPtMin || pt >= fPtMax ) pass=kFALSE;} |
| 924b02b0 |
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;} |
| 957517fa |
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 |
| 32b846cd |
590 | if (charge!=fCharge) pass=kFALSE; |
| 957517fa |
591 | } |
| 924b02b0 |
592 | //if(fCutPID) {if (fTrack->PID() != fPID) pass=kFALSE;} |
| daf66719 |
593 | |
| 957517fa |
594 | //when additionally MC info is required |
| 1ff4bda1 |
595 | if (fCutMC && !PassesMCcuts()) pass=kFALSE; |
| daf66719 |
596 | |
| 42655d16 |
597 | //the case of ESD or AOD |
| bb6ca457 |
598 | if (esdTrack) { if (!PassesESDcuts(esdTrack)) { pass=kFALSE; } } |
| 599 | if (aodTrack) { if (!PassesAODcuts(aodTrack)) { pass=kFALSE; } } |
| 42655d16 |
600 | |
| f21bdf48 |
601 | if (fQA) |
| 602 | { |
| c3eb0b6c |
603 | if (fMCparticle) |
| f21bdf48 |
604 | { |
| 875ee12a |
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 | |
| c3eb0b6c |
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); |
| 875ee12a |
632 | QAbefore(4)->Fill(p,static_cast<Float_t>(processID)); |
| c3eb0b6c |
633 | if (pass) QAafter(2)->Fill(p,pdg); |
| 634 | if (pass) QAafter(3)->Fill(p,IsPhysicalPrimary()?0.5:-0.5); |
| 875ee12a |
635 | if (pass) QAafter(4)->Fill(p,static_cast<Float_t>(processID)); |
| f21bdf48 |
636 | } |
| f21bdf48 |
637 | } |
| 638 | |
| 42655d16 |
639 | //true by default, if we didn't set any cuts |
| 640 | return pass; |
| 641 | } |
| 642 | |
| 643 | //_______________________________________________________________________ |
| 1a80f9f6 |
644 | Bool_t AliFlowTrackCuts::PassesAODcuts(const AliAODTrack* track) |
| 42655d16 |
645 | { |
| 1a80f9f6 |
646 | //check cuts for AOD |
| 42655d16 |
647 | Bool_t pass = kTRUE; |
| 648 | |
| 649 | if (fCutNClustersTPC) |
| 1ff4bda1 |
650 | { |
| 42655d16 |
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 | } |
| 5ba02b32 |
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 | |
| a63303bd |
672 | if (fCutDCAToVertexXY && track->DCA()>GetMaxDCAToVertexXY()) pass=kFALSE; |
| 5ba02b32 |
673 | |
| 42655d16 |
674 | |
| 675 | return pass; |
| 676 | } |
| 677 | |
| 678 | //_______________________________________________________________________ |
| 679 | Bool_t AliFlowTrackCuts::PassesESDcuts(AliESDtrack* track) |
| 680 | { |
| 1a80f9f6 |
681 | //check cuts on ESD tracks |
| 42655d16 |
682 | Bool_t pass=kTRUE; |
| 499fe731 |
683 | const AliExternalTrackParam* pout = track->GetOuterParam(); |
| 684 | const AliExternalTrackParam* pin = track->GetInnerParam(); |
| 42655d16 |
685 | if (fIgnoreTPCzRange) |
| 686 | { |
| 42655d16 |
687 | if (pin&&pout) |
| 441ea1cf |
688 | { |
| 42655d16 |
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; |
| 441ea1cf |
694 | } |
| 42655d16 |
695 | } |
| 32b846cd |
696 | |
| 1a80f9f6 |
697 | Int_t ntpccls = ( fParamType==kTPCstandalone )? |
| 42655d16 |
698 | track->GetTPCNclsIter1():track->GetTPCNcls(); |
| 699 | if (fCutChi2PerClusterTPC) |
| 700 | { |
| 1a80f9f6 |
701 | Float_t tpcchi2 = (fParamType==kTPCstandalone)? |
| 42655d16 |
702 | track->GetTPCchi2Iter1():track->GetTPCchi2(); |
| 703 | tpcchi2 = (ntpccls>0)?tpcchi2/ntpccls:-FLT_MAX; |
| 704 | if (tpcchi2<fMinChi2PerClusterTPC || tpcchi2 >=fMaxChi2PerClusterTPC) |
| 705 | pass=kFALSE; |
| 706 | } |
| 707 | |
| 2b1eaa10 |
708 | if (fCutMinimalTPCdedx) |
| 709 | { |
| 710 | if (track->GetTPCsignal() < fMinimalTPCdedx) pass=kFALSE; |
| 711 | } |
| 712 | |
| 42655d16 |
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 | } |
| 32b846cd |
723 | |
| 1a80f9f6 |
724 | //some stuff is still handled by AliESDtrackCuts class - delegate |
| 725 | if (fAliESDtrackCuts) |
| 726 | { |
| 727 | if (!fAliESDtrackCuts->IsSelected(track)) pass=kFALSE; |
| 728 | } |
| 729 | |
| 499fe731 |
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 | } |
| a14b8f3c |
737 | if (fCutPID && (fParticleID!=AliPID::kUnknown)) //if kUnknown don't cut on PID |
| 42655d16 |
738 | { |
| 739 | switch (fPIDsource) |
| 32b846cd |
740 | { |
| 42655d16 |
741 | case kTPCpid: |
| 742 | if (!PassesTPCpidCut(track)) pass=kFALSE; |
| 743 | break; |
| 2b1eaa10 |
744 | case kTPCdedx: |
| 745 | if (!PassesTPCdedxCut(track)) pass=kFALSE; |
| 746 | break; |
| 42655d16 |
747 | case kTOFpid: |
| 748 | if (!PassesTOFpidCut(track)) pass=kFALSE; |
| 749 | break; |
| 2b1eaa10 |
750 | case kTOFbeta: |
| 751 | if (!PassesTOFbetaCut(track)) pass=kFALSE; |
| 1a80f9f6 |
752 | break; |
| 753 | case kTOFbetaSimple: |
| 754 | if (!PassesTOFbetaSimpleCut(track)) pass=kFALSE; |
| 42655d16 |
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; |
| 32b846cd |
765 | } |
| 42655d16 |
766 | } |
| 499fe731 |
767 | if (fQA) |
| 768 | { |
| 769 | if (pass) QAafter(0)->Fill(track->GetP(),beta); |
| 770 | if (pass) QAafter(1)->Fill(pin->GetP(),dedx); |
| 771 | } |
| 32b846cd |
772 | |
| 42655d16 |
773 | return pass; |
| daf66719 |
774 | } |
| 775 | |
| 776 | //----------------------------------------------------------------------- |
| 777 | void AliFlowTrackCuts::HandleVParticle(AliVParticle* track) |
| 778 | { |
| 779 | //handle the general case |
| daf66719 |
780 | switch (fParamType) |
| 781 | { |
| daf66719 |
782 | default: |
| daf66719 |
783 | fTrack = track; |
| 32b846cd |
784 | break; |
| daf66719 |
785 | } |
| 786 | } |
| 787 | |
| 788 | //----------------------------------------------------------------------- |
| 789 | void AliFlowTrackCuts::HandleESDtrack(AliESDtrack* track) |
| 790 | { |
| 791 | //handle esd track |
| daf66719 |
792 | switch (fParamType) |
| 793 | { |
| 12b2b8bc |
794 | case kGlobal: |
| daf66719 |
795 | fTrack = track; |
| daf66719 |
796 | break; |
| 1a80f9f6 |
797 | case kTPCstandalone: |
| 2b1eaa10 |
798 | if (!track->FillTPCOnlyTrack(fTPCtrack)) |
| 1ff4bda1 |
799 | { |
| 800 | fTrack=NULL; |
| 801 | fMCparticle=NULL; |
| 802 | fTrackLabel=-1; |
| 803 | return; |
| 804 | } |
| 805 | fTrack = &fTPCtrack; |
| 957517fa |
806 | //recalculate the label and mc particle, they may differ as TPClabel != global label |
| 127a5825 |
807 | fTrackLabel = (fFakesAreOK)?TMath::Abs(fTrack->GetLabel()):fTrack->GetLabel(); |
| 808 | if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel)); |
| 957517fa |
809 | else fMCparticle=NULL; |
| daf66719 |
810 | break; |
| daf66719 |
811 | default: |
| 812 | fTrack = track; |
| 32b846cd |
813 | break; |
| daf66719 |
814 | } |
| 815 | } |
| 816 | |
| a0241c3a |
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 | |
| 1a80f9f6 |
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 | |
| a0241c3a |
852 | //----------------------------------------------------------------------- |
| 853 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardGlobalTrackCuts2010() |
| 854 | { |
| 855 | //get standard cuts |
| 1a80f9f6 |
856 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard Global tracks"); |
| a0241c3a |
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); |
| 2b1eaa10 |
869 | cuts->SetMinimalTPCdedx(10.); |
| a0241c3a |
870 | |
| 871 | return cuts; |
| 872 | } |
| 873 | |
| 874 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
875 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010() |
| a0241c3a |
876 | { |
| 877 | //get standard cuts |
| 1a80f9f6 |
878 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard TPC standalone 2010"); |
| 879 | cuts->SetParamType(kTPCstandalone); |
| a0241c3a |
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); |
| 2b1eaa10 |
889 | cuts->SetMinimalTPCdedx(10.); |
| a0241c3a |
890 | |
| 891 | return cuts; |
| 892 | } |
| 893 | |
| daf66719 |
894 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
895 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts() |
| daf66719 |
896 | { |
| 897 | //get standard cuts |
| 1a80f9f6 |
898 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard TPC standalone"); |
| 899 | cuts->SetParamType(kTPCstandalone); |
| a0241c3a |
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); |
| 2b1eaa10 |
909 | cuts->SetMinimalTPCdedx(10.); |
| a0241c3a |
910 | |
| daf66719 |
911 | return cuts; |
| 912 | } |
| 913 | |
| 914 | //----------------------------------------------------------------------- |
| 915 | AliFlowTrackCuts* AliFlowTrackCuts::GetStandardITSTPCTrackCuts2009(Bool_t selPrimaries) |
| 916 | { |
| 917 | //get standard cuts |
| 441ea1cf |
918 | AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard global track cuts 2009"); |
| daf66719 |
919 | delete cuts->fAliESDtrackCuts; |
| 920 | cuts->fAliESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selPrimaries); |
| 12b2b8bc |
921 | cuts->SetParamType(kGlobal); |
| daf66719 |
922 | return cuts; |
| 923 | } |
| 924 | |
| 7d27a354 |
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 | } |
| 499fe731 |
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 | } |
| 7d27a354 |
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 | |
| daf66719 |
1051 | //----------------------------------------------------------------------- |
| d148af7e |
1052 | AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackSPDtracklet() const |
| daf66719 |
1053 | { |
| d148af7e |
1054 | //make a flow track from tracklet |
| daf66719 |
1055 | AliFlowTrack* flowtrack=NULL; |
| d0471ea0 |
1056 | TParticle *tmpTParticle=NULL; |
| 1057 | AliMCParticle* tmpAliMCParticle=NULL; |
| d148af7e |
1058 | switch (fParamMix) |
| daf66719 |
1059 | { |
| d148af7e |
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; |
| 12b2b8bc |
1093 | } |
| d148af7e |
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; |
| d79d61fb |
1106 | AliExternalTrackParam* externalParams=NULL; |
| 1107 | AliESDtrack* esdtrack=NULL; |
| d148af7e |
1108 | switch(fParamMix) |
| 12b2b8bc |
1109 | { |
| d148af7e |
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; |
| d79d61fb |
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); |
| 99cdfc57 |
1138 | break; |
| d148af7e |
1139 | default: |
| 1140 | flowtrack = new AliFlowTrack(fTrack); |
| 1141 | break; |
| 1142 | } |
| 499fe731 |
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 | } |
| d148af7e |
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; |
| daf66719 |
1213 | } |
| 6e214c87 |
1214 | |
| d148af7e |
1215 | flowtrack->SetSource(AliFlowTrack::kFromPMD); |
| daf66719 |
1216 | return flowtrack; |
| 1217 | } |
| 127a5825 |
1218 | |
| 22289738 |
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 | |
| d148af7e |
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 |
| 22289738 |
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. |
| d148af7e |
1281 | switch (fParamType) |
| 1282 | { |
| 1a80f9f6 |
1283 | case kSPDtracklet: |
| d148af7e |
1284 | return MakeFlowTrackSPDtracklet(); |
| 1285 | case kPMD: |
| 1286 | return MakeFlowTrackPMDtrack(); |
| 22289738 |
1287 | case kV0: |
| 1288 | return MakeFlowTrackV0(); |
| d148af7e |
1289 | default: |
| 1290 | return MakeFlowTrackVParticle(); |
| 1291 | } |
| 1292 | } |
| 1293 | |
| 127a5825 |
1294 | //----------------------------------------------------------------------- |
| 1295 | Bool_t AliFlowTrackCuts::IsPhysicalPrimary() const |
| 1296 | { |
| 1297 | //check if current particle is a physical primary |
| 9a0783cc |
1298 | if (!fMCevent) return kFALSE; |
| 1299 | if (fTrackLabel<0) return kFALSE; |
| 441ea1cf |
1300 | return IsPhysicalPrimary(fMCevent, fTrackLabel, fRequireTransportBitForPrimaries); |
| 9a0783cc |
1301 | } |
| 1302 | |
| 1303 | //----------------------------------------------------------------------- |
| 441ea1cf |
1304 | Bool_t AliFlowTrackCuts::IsPhysicalPrimary(AliMCEvent* mcEvent, Int_t label, Bool_t requiretransported) |
| 9a0783cc |
1305 | { |
| 1306 | //check if current particle is a physical primary |
| 1307 | Bool_t physprim=mcEvent->IsPhysicalPrimary(label); |
| 9a0783cc |
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); |
| 441ea1cf |
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)); |
| 127a5825 |
1315 | } |
| 12b2b8bc |
1316 | |
| 924b02b0 |
1317 | //----------------------------------------------------------------------- |
| 1318 | void AliFlowTrackCuts::DefineHistograms() |
| 1319 | { |
| 2a745a5f |
1320 | //define qa histograms |
| 1a80f9f6 |
1321 | if (fQA) return; |
| 1322 | |
| 499fe731 |
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++) |
| 1a80f9f6 |
1327 | { |
| 499fe731 |
1328 | if(binsP[i-1]+0.05<1.01) |
| 1329 | binsP[i]=binsP[i-1]+0.05; |
| 1a80f9f6 |
1330 | else |
| 499fe731 |
1331 | binsP[i]=binsP[i-1]+0.1; |
| 1a80f9f6 |
1332 | } |
| 1333 | |
| 499fe731 |
1334 | Bool_t adddirstatus = TH1::AddDirectoryStatus(); |
| 1335 | TH1::AddDirectory(kFALSE); |
| a14b8f3c |
1336 | fQA=new TList(); fQA->SetOwner(); |
| 499fe731 |
1337 | fQA->SetName(Form("%s QA",GetName())); |
| a14b8f3c |
1338 | TList* before = new TList(); before->SetOwner(); |
| 499fe731 |
1339 | before->SetName("before"); |
| a14b8f3c |
1340 | TList* after = new TList(); after->SetOwner(); |
| 499fe731 |
1341 | after->SetName("after"); |
| 1342 | fQA->Add(before); |
| 1343 | fQA->Add(after); |
| f21bdf48 |
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 |
| 875ee12a |
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 | |
| 499fe731 |
1371 | TH1::AddDirectory(adddirstatus); |
| 924b02b0 |
1372 | } |
| 9a0783cc |
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 | { |
| 1a80f9f6 |
1382 | case kSPDtracklet: |
| 9a0783cc |
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(); |
| d148af7e |
1389 | case kPMD: |
| 1390 | esd = dynamic_cast<AliESDEvent*>(fEvent); |
| 1391 | if (!esd) return 0; |
| 1392 | return esd->GetNumberOfPmdTracks(); |
| 22289738 |
1393 | case kV0: |
| 1394 | return fgkNumberOfV0tracks; |
| 9a0783cc |
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 | { |
| 1a80f9f6 |
1410 | case kSPDtracklet: |
| 9a0783cc |
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); |
| d148af7e |
1417 | case kPMD: |
| 1418 | esd = dynamic_cast<AliESDEvent*>(fEvent); |
| 1419 | if (!esd) return NULL; |
| 1420 | return esd->GetPmdTrack(i); |
| 22289738 |
1421 | case kV0: |
| 1422 | esd = dynamic_cast<AliESDEvent*>(fEvent); |
| a14b8f3c |
1423 | if (!esd) return NULL; |
| 22289738 |
1424 | return esd->GetVZEROData(); |
| 9a0783cc |
1425 | default: |
| 1426 | if (!fEvent) return NULL; |
| 1427 | return fEvent->GetTrack(i); |
| 1428 | } |
| 1429 | } |
| a1c43d26 |
1430 | |
| 1431 | //----------------------------------------------------------------------- |
| 1432 | void AliFlowTrackCuts::Clear(Option_t*) |
| 1433 | { |
| 1434 | //clean up |
| 1435 | fTrack=NULL; |
| 1436 | fMCevent=NULL; |
| 1437 | fMCparticle=NULL; |
| 22289738 |
1438 | fTrackLabel=-1; |
| a1c43d26 |
1439 | fTrackWeight=0.0; |
| 1440 | fTrackEta=0.0; |
| 1441 | fTrackPhi=0.0; |
| 1442 | } |
| 32b846cd |
1443 | |
| 1444 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
1445 | Bool_t AliFlowTrackCuts::PassesTOFbetaSimpleCut(const AliESDtrack* track ) |
| 32b846cd |
1446 | { |
| 1447 | //check if passes PID cut using timing in TOF |
| a14b8f3c |
1448 | Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) && |
| b092f828 |
1449 | (track->GetTOFsignal() > 12000) && |
| 1450 | (track->GetTOFsignal() < 100000) && |
| 499fe731 |
1451 | (track->GetIntegratedLength() > 365); |
| 1452 | |
| 875ee12a |
1453 | if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;} |
| 1454 | |
| 1455 | Bool_t statusMatchingHard = TPCTOFagree(track); |
| 1456 | if (fRequireStrictTOFTPCagreement && (!statusMatchingHard)) |
| 1457 | return kFALSE; |
| aab6527a |
1458 | |
| 1459 | if (!goodtrack) return kFALSE; |
| 1460 | |
| a0241c3a |
1461 | const Float_t c = 2.99792457999999984e-02; |
| b092f828 |
1462 | Float_t p = track->GetP(); |
| 1a80f9f6 |
1463 | Float_t l = track->GetIntegratedLength(); |
| aab6527a |
1464 | Float_t trackT0 = fESDpid.GetTOFResponse().GetStartTime(p); |
| b092f828 |
1465 | Float_t timeTOF = track->GetTOFsignal()- trackT0; |
| 1a80f9f6 |
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) && |
| 7288f660 |
1481 | (s[3]>0.025) && |
| 1482 | (s[4]>0.03) ); |
| 1a80f9f6 |
1483 | case AliPID::kKaon: |
| 1484 | return ( (s[3]<0.015) && (s[3]>-0.015) && |
| 7288f660 |
1485 | (s[2]<-0.03) && |
| 1486 | (s[4]>0.03) ); |
| 1a80f9f6 |
1487 | case AliPID::kProton: |
| 499fe731 |
1488 | return ( (s[4]<0.015) && (s[4]>-0.015) && |
| 7288f660 |
1489 | (s[3]<-0.025) && |
| 1490 | (s[2]<-0.025) ); |
| 1a80f9f6 |
1491 | default: |
| 1492 | return kFALSE; |
| 1493 | } |
| 1494 | return kFALSE; |
| 1495 | } |
| 1496 | |
| 499fe731 |
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 | |
| 1a80f9f6 |
1509 | //----------------------------------------------------------------------- |
| 1510 | Bool_t AliFlowTrackCuts::PassesTOFbetaCut(const AliESDtrack* track ) |
| 1511 | { |
| 1512 | //check if passes PID cut using timing in TOF |
| a14b8f3c |
1513 | Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) && |
| 1a80f9f6 |
1514 | (track->GetTOFsignal() > 12000) && |
| 1515 | (track->GetTOFsignal() < 100000) && |
| 499fe731 |
1516 | (track->GetIntegratedLength() > 365); |
| 1517 | |
| 875ee12a |
1518 | if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;} |
| 1519 | |
| 1520 | Bool_t statusMatchingHard = TPCTOFagree(track); |
| 1521 | if (fRequireStrictTOFTPCagreement && (!statusMatchingHard)) |
| 1522 | return kFALSE; |
| 1a80f9f6 |
1523 | |
| 1524 | if (!goodtrack) return kFALSE; |
| 1525 | |
| 499fe731 |
1526 | Float_t beta = GetBeta(track); |
| 1527 | |
| a0241c3a |
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 |
| 32b846cd |
1532 | Int_t pid = 0; |
| 2b1eaa10 |
1533 | switch (fParticleID) |
| 32b846cd |
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 | } |
| a0241c3a |
1547 | |
| 1548 | //signal to cut on |
| 499fe731 |
1549 | const Float_t c = 2.99792457999999984e-02; |
| 1550 | Float_t l = track->GetIntegratedLength(); |
| 1551 | Float_t p = track->GetP(); |
| 1a80f9f6 |
1552 | Float_t betahypothesis = l/integratedTimes[pid]/c; |
| 1553 | Float_t betadiff = beta-betahypothesis; |
| 32b846cd |
1554 | |
| 1555 | Float_t* arr = fTOFpidCuts->GetMatrixArray(); |
| a0241c3a |
1556 | Int_t col = TMath::BinarySearch(fTOFpidCuts->GetNcols(),arr,static_cast<Float_t>(p)); |
| 32b846cd |
1557 | if (col<0) return kFALSE; |
| 1558 | Float_t min = (*fTOFpidCuts)(1,col); |
| 1559 | Float_t max = (*fTOFpidCuts)(2,col); |
| 1560 | |
| 1a80f9f6 |
1561 | Bool_t pass = (betadiff>min && betadiff<max); |
| 1562 | |
| 1a80f9f6 |
1563 | return pass; |
| 32b846cd |
1564 | } |
| 1565 | |
| 2b1eaa10 |
1566 | //----------------------------------------------------------------------- |
| 7d27a354 |
1567 | Bool_t AliFlowTrackCuts::PassesTOFpidCut(const AliESDtrack* track) const |
| 2b1eaa10 |
1568 | { |
| 1569 | //check if passes PID cut using default TOF pid |
| 7d27a354 |
1570 | Double_t pidTOF[AliPID::kSPECIES]; |
| 1571 | track->GetTOFpid(pidTOF); |
| 1572 | if (pidTOF[fParticleID]>=fParticleProbability) return kTRUE; |
| 2b1eaa10 |
1573 | return kFALSE; |
| 1574 | } |
| 1575 | |
| 32b846cd |
1576 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
1577 | Bool_t AliFlowTrackCuts::PassesTPCpidCut(const AliESDtrack* track) const |
| 2b1eaa10 |
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 | |
| 499fe731 |
1595 | //----------------------------------------------------------------------- |
| 1596 | Float_t AliFlowTrackCuts::Getdedx(const AliESDtrack* track) |
| 1597 | { |
| 1598 | //get TPC dedx |
| 1599 | return track->GetTPCsignal(); |
| 1600 | } |
| 1601 | |
| 2b1eaa10 |
1602 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
1603 | Bool_t AliFlowTrackCuts::PassesTPCdedxCut(const AliESDtrack* track) |
| 32b846cd |
1604 | { |
| 1605 | //check if passes PID cut using dedx signal in the TPC |
| 32b846cd |
1606 | if (!fTPCpidCuts) |
| 1607 | { |
| 1608 | printf("no TPCpidCuts\n"); |
| 1609 | return kFALSE; |
| 1610 | } |
| 1611 | |
| 3c75bbd5 |
1612 | const AliExternalTrackParam* tpcparam = track->GetInnerParam(); //tpc only params at the inner wall |
| 1613 | if (!tpcparam) return kFALSE; |
| d79d61fb |
1614 | Double_t p = tpcparam->GetP(); |
| 1615 | Float_t sigExp = fESDpid.GetTPCResponse().GetExpectedSignal(p, fParticleID); |
| 32b846cd |
1616 | Float_t sigTPC = track->GetTPCsignal(); |
| 1617 | Float_t s = (sigTPC-sigExp)/sigExp; |
| 32b846cd |
1618 | |
| 1619 | Float_t* arr = fTPCpidCuts->GetMatrixArray(); |
| 1a80f9f6 |
1620 | Int_t arrSize = fTPCpidCuts->GetNcols(); |
| 1621 | Int_t col = TMath::BinarySearch( arrSize, arr, static_cast<Float_t>(p)); |
| 32b846cd |
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 | { |
| 2b1eaa10 |
1637 | if (fParticleID==AliPID::kPion) |
| 32b846cd |
1638 | { |
| d79d61fb |
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; |
| 32b846cd |
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; |
| d79d61fb |
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; |
| 32b846cd |
1655 | } |
| 1656 | else |
| 2b1eaa10 |
1657 | if (fParticleID==AliPID::kKaon) |
| 3ca4688a |
1658 | { |
| d79d61fb |
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; |
| 1a80f9f6 |
1671 | (*t)(0,11) = 0.75; (*t)(1,11) = 0; (*t)(2,11) = 0; |
| 3ca4688a |
1672 | } |
| 1673 | else |
| 2b1eaa10 |
1674 | if (fParticleID==AliPID::kProton) |
| 32b846cd |
1675 | { |
| d79d61fb |
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; |
| 32b846cd |
1686 | } |
| d79d61fb |
1687 | delete fTPCpidCuts; |
| 32b846cd |
1688 | fTPCpidCuts=t; |
| 1689 | } |
| 7d9ab4fb |
1690 | t = NULL; |
| 32b846cd |
1691 | if (!fTOFpidCuts) |
| 1692 | { |
| 2b1eaa10 |
1693 | if (fParticleID==AliPID::kPion) |
| 32b846cd |
1694 | { |
| a0241c3a |
1695 | //TOF pions, 0.9 purity |
| 1696 | t = new TMatrixF(3,61); |
| d79d61fb |
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; |
| 1a80f9f6 |
1701 | (*t)(0,4) = 0.200; (*t)(1,4) = -0.030; (*t)(2,4) = 0.030; |
| d79d61fb |
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; |
| 32b846cd |
1758 | } |
| 1759 | else |
| 2b1eaa10 |
1760 | if (fParticleID==AliPID::kProton) |
| 32b846cd |
1761 | { |
| a0241c3a |
1762 | //TOF protons, 0.9 purity |
| 1763 | t = new TMatrixF(3,61); |
| d79d61fb |
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; |
| 1a80f9f6 |
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; |
| d79d61fb |
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; |
| 32b846cd |
1825 | } |
| 1826 | else |
| 2b1eaa10 |
1827 | if (fParticleID==AliPID::kKaon) |
| 32b846cd |
1828 | { |
| a0241c3a |
1829 | //TOF kaons, 0.9 purity |
| 1830 | t = new TMatrixF(3,61); |
| d79d61fb |
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; |
| 1a80f9f6 |
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; |
| d79d61fb |
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; |
| 32b846cd |
1892 | } |
| d79d61fb |
1893 | delete fTOFpidCuts; |
| 32b846cd |
1894 | fTOFpidCuts=t; |
| 1895 | } |
| 1896 | } |
| 3abf7ecc |
1897 | |
| 1898 | //----------------------------------------------------------------------- |
| 1899 | // part added by F. Noferini (some methods) |
| 875ee12a |
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); |
| 3abf7ecc |
1908 | |
| 875ee12a |
1909 | if (! fAllowTOFmismatchFlag) {if (track->GetStatus() & AliESDtrack::kTOFmismatch) return kFALSE;} |
| 3abf7ecc |
1910 | |
| 1911 | if (! goodtrack) |
| 1912 | return kFALSE; |
| 1913 | |
| 875ee12a |
1914 | Bool_t statusMatchingHard = TPCTOFagree(track); |
| 1915 | if (fRequireStrictTOFTPCagreement && (!statusMatchingHard)) |
| 1916 | return kFALSE; |
| 1917 | |
| 3abf7ecc |
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; |
| 2b1eaa10 |
1923 | switch (fParticleID) |
| 3abf7ecc |
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); |
| 875ee12a |
1946 | if(TMath::Abs(pdg) == TMath::Abs(pid) && prob > fParticleProbability){ |
| 3abf7ecc |
1947 | if(!fCutCharge) |
| 1948 | return kTRUE; |
| 1949 | else if (fCutCharge && fCharge * track->GetSign() > 0) |
| 1950 | return kTRUE; |
| 1951 | } |
| 1952 | return kFALSE; |
| 1953 | } |
| 875ee12a |
1954 | |
| 3abf7ecc |
1955 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
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 |
| 3abf7ecc |
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; |
| 1a80f9f6 |
1970 | while(pt > fBinLimitPID[iptesd] && iptesd < fgkPIDptBin-1) iptesd++; |
| 3abf7ecc |
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; |
| 1a80f9f6 |
2021 | while(pt > fBinLimitPID[iptesd] && iptesd < fgkPIDptBin-1) iptesd++; |
| 3abf7ecc |
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; |
| 1a80f9f6 |
2072 | while(pt > fBinLimitPID[iptesd] && iptesd < fgkPIDptBin-1) iptesd++; |
| 3abf7ecc |
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 | |
| 875ee12a |
2092 | r1[0] = TMath::Min(r1[2],r1[0]); |
| 2093 | r1[1] = TMath::Min(r1[2],r1[1]); |
| 2094 | |
| 3abf7ecc |
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 |
| aab6527a |
2131 | // like fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[ipart], mass[ipart]); |
| 2132 | Float_t resolution = fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[ipart], mass[ipart]); |
| 3abf7ecc |
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 | } |
| 875ee12a |
2145 | |
| 3abf7ecc |
2146 | //----------------------------------------------------------------------- |
| 875ee12a |
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; |
| 3abf7ecc |
3252 | } |
| 3253 | // end part added by F. Noferini |
| 3254 | //----------------------------------------------------------------------- |
| 2b1eaa10 |
3255 | |
| 2b1eaa10 |
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"; |
| 1a80f9f6 |
3272 | case kTOFbetaSimple: |
| 3273 | return "TOFbetaSimple"; |
| 2b1eaa10 |
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: |
| 1a80f9f6 |
3288 | return "Global"; |
| 3289 | case kTPCstandalone: |
| 3290 | return "TPCstandalone"; |
| 3291 | case kSPDtracklet: |
| 3292 | return "SPDtracklets"; |
| d148af7e |
3293 | case kPMD: |
| 3294 | return "PMD"; |
| 22289738 |
3295 | case kV0: |
| 3296 | return "V0"; |
| 2b1eaa10 |
3297 | default: |
| 3298 | return "unknown"; |
| 3299 | } |
| 3300 | } |
| 3301 | |
| d148af7e |
3302 | //----------------------------------------------------------------------- |
| 1a80f9f6 |
3303 | Bool_t AliFlowTrackCuts::PassesPMDcuts(AliESDPmdTrack* track ) |
| d148af7e |
3304 | { |
| 3305 | //check PMD specific cuts |
| 3306 | //clean up from last iteration, and init label |
| 1a80f9f6 |
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(); |
| d148af7e |
3314 | |
| 3315 | fTrack = NULL; |
| 3316 | fMCparticle=NULL; |
| 3317 | fTrackLabel=-1; |
| 3318 | |
| 1a80f9f6 |
3319 | fTrackEta = GetPmdEta(clsX,clsY,clsZ); |
| 3320 | fTrackPhi = GetPmdPhi(clsX,clsY); |
| d148af7e |
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;} |
| 1a80f9f6 |
3326 | if (fCutPmdDet) {if(det != fPmdDet) pass = kFALSE;} |
| 3327 | if (fCutPmdAdc) {if(adc < fPmdAdc) pass = kFALSE;} |
| 3328 | if (fCutPmdNcell) {if(ncell < fPmdNcell) pass = kFALSE;} |
| d148af7e |
3329 | |
| 1a80f9f6 |
3330 | return pass; |
| d148af7e |
3331 | } |
| 22289738 |
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 | |
| 1a80f9f6 |
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 |
| 22289738 |
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 | |
| 1a80f9f6 |
3354 | return pass; |
| 22289738 |
3355 | } |
| 3356 | |
| 1a80f9f6 |
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 | } |
| 499fe731 |
3391 | |
| 3392 | //---------------------------------------------------------------// |
| 3393 | void AliFlowTrackCuts::Browse(TBrowser* b) |
| 3394 | { |
| 3395 | //some browsing capabilities |
| 3396 | if (fQA) b->Add(fQA); |
| 3397 | } |
| 3398 | |
| 1a80f9f6 |
3399 | //---------------------------------------------------------------// |
| 499fe731 |
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 | } |
| f21bdf48 |
3418 | |
git://git.uio.no / u / mrichter / AliRoot.git / blame