]>
Commit | Line | Data |
---|---|---|
809a4336 | 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 | **************************************************************************/ | |
50685501 | 15 | // |
16 | // Class for TPC PID | |
17 | // Implements the abstract base class AliHFEpidBase | |
18 | // | |
19 | // Class contains TPC specific cuts and QA histograms | |
20 | // Two selection strategies are offered: Selection of certain value | |
21 | // regions in the TPC dE/dx (by IsSelected), and likelihoods | |
22 | // | |
23 | // Authors: | |
24 | // | |
25 | // Markus Fasel <M.Fasel@gsi.de> | |
26 | // Markus Heide <mheide@uni-muenster.de> | |
27 | // | |
faee3b18 | 28 | #include <TF1.h> |
809a4336 | 29 | #include <TMath.h> |
1a319cb5 | 30 | #include <TH2D.h> |
809a4336 | 31 | |
cedf0381 | 32 | #include "AliTPCdEdxInfo.h" |
6555e2ad | 33 | #include "AliAODPid.h" |
722347d8 | 34 | #include "AliAODTrack.h" |
35 | #include "AliAODMCParticle.h" | |
809a4336 | 36 | #include "AliESDtrack.h" |
37 | #include "AliExternalTrackParam.h" | |
38 | #include "AliLog.h" | |
722347d8 | 39 | #include "AliMCParticle.h" |
809a4336 | 40 | #include "AliPID.h" |
8c1c76e9 | 41 | #include "AliPIDResponse.h" |
809a4336 | 42 | |
43 | #include "AliHFEpidTPC.h" | |
3a72645a | 44 | #include "AliHFEpidQAmanager.h" |
809a4336 | 45 | |
faee3b18 | 46 | ClassImp(AliHFEpidTPC) |
809a4336 | 47 | |
3a72645a | 48 | //___________________________________________________________________ |
49 | AliHFEpidTPC::AliHFEpidTPC() : | |
50 | // add a list here | |
51 | AliHFEpidBase() | |
3a72645a | 52 | , fLineCrossingsEnabled(0) |
11ff28c5 | 53 | , fkEtaCorrection(NULL) |
959ea9d8 | 54 | , fkCentralityCorrection(NULL) |
38be5083 | 55 | , fkEtaMeanCorrection(NULL) |
56 | , fkEtaWidthCorrection(NULL) | |
57 | , fkCentralityMeanCorrection(NULL) | |
58 | , fkCentralityWidthCorrection(NULL) | |
562897a9 | 59 | , fkCentralityEtaCorrectionMeanJpsi(NULL) |
60 | , fkCentralityEtaCorrectionWidthJpsi(NULL) | |
e156c3bb | 61 | , fHasCutModel(kFALSE) |
cedf0381 | 62 | , fUseOnlyOROC(kFALSE) |
3a72645a | 63 | , fNsigmaTPC(3) |
64 | , fRejectionEnabled(0) | |
4437a0d2 | 65 | , fUsedEdx(kFALSE) |
3a72645a | 66 | { |
67 | // | |
68 | // default constructor | |
69 | // | |
e156c3bb | 70 | |
71 | memset(fkUpperSigmaCut, 0, sizeof(const TF1 *) * 12); | |
72 | memset(fkLowerSigmaCut, 0, sizeof(const TF1 *) * 12); | |
73 | ||
bf892a6a | 74 | memset(fRejection, 0, sizeof(Float_t) * 4 * AliPID::kSPECIES); |
75 | memset(fLineCrossingSigma, 0, sizeof(Double_t) * AliPID::kSPECIES); | |
76 | memset(fPAsigCut, 0, sizeof(Float_t) * 2); | |
77 | memset(fNAsigmaTPC, 0, sizeof(Float_t) * 2); | |
78 | ||
3a72645a | 79 | } |
80 | ||
809a4336 | 81 | //___________________________________________________________________ |
82 | AliHFEpidTPC::AliHFEpidTPC(const char* name) : | |
83 | // add a list here | |
9bcfd1ab | 84 | AliHFEpidBase(name) |
809a4336 | 85 | , fLineCrossingsEnabled(0) |
11ff28c5 | 86 | , fkEtaCorrection(NULL) |
959ea9d8 | 87 | , fkCentralityCorrection(NULL) |
38be5083 | 88 | , fkEtaMeanCorrection(NULL) |
89 | , fkEtaWidthCorrection(NULL) | |
90 | , fkCentralityMeanCorrection(NULL) | |
91 | , fkCentralityWidthCorrection(NULL) | |
1a319cb5 | 92 | , fkCentralityEtaCorrectionMeanJpsi(NULL) |
93 | , fkCentralityEtaCorrectionWidthJpsi(NULL) | |
e156c3bb | 94 | , fHasCutModel(kFALSE) |
cedf0381 | 95 | , fUseOnlyOROC(kFALSE) |
75d81601 | 96 | , fNsigmaTPC(3) |
0792aa82 | 97 | , fRejectionEnabled(0) |
4437a0d2 | 98 | , fUsedEdx(kFALSE) |
809a4336 | 99 | { |
100 | // | |
101 | // default constructor | |
102 | // | |
bf892a6a | 103 | // |
e156c3bb | 104 | memset(fkUpperSigmaCut, 0, sizeof(const TF1 *) * 12); |
105 | memset(fkLowerSigmaCut, 0, sizeof(const TF1 *) * 12); | |
106 | ||
bf892a6a | 107 | memset(fRejection, 0, sizeof(Float_t) * 4 * AliPID::kSPECIES); |
809a4336 | 108 | memset(fLineCrossingSigma, 0, sizeof(Double_t) * AliPID::kSPECIES); |
722347d8 | 109 | memset(fPAsigCut, 0, sizeof(Float_t) * 2); |
110 | memset(fNAsigmaTPC, 0, sizeof(Float_t) * 2); | |
809a4336 | 111 | } |
112 | ||
113 | //___________________________________________________________________ | |
114 | AliHFEpidTPC::AliHFEpidTPC(const AliHFEpidTPC &ref) : | |
9bcfd1ab | 115 | AliHFEpidBase("") |
809a4336 | 116 | , fLineCrossingsEnabled(0) |
11ff28c5 | 117 | , fkEtaCorrection(NULL) |
959ea9d8 | 118 | , fkCentralityCorrection(NULL) |
38be5083 | 119 | , fkEtaMeanCorrection(NULL) |
120 | , fkEtaWidthCorrection(NULL) | |
121 | , fkCentralityMeanCorrection(NULL) | |
122 | , fkCentralityWidthCorrection(NULL) | |
1a319cb5 | 123 | , fkCentralityEtaCorrectionMeanJpsi(NULL) |
124 | , fkCentralityEtaCorrectionWidthJpsi(NULL) | |
e156c3bb | 125 | , fHasCutModel(ref.fHasCutModel) |
cedf0381 | 126 | , fUseOnlyOROC(ref.fUseOnlyOROC) |
809a4336 | 127 | , fNsigmaTPC(2) |
0792aa82 | 128 | , fRejectionEnabled(0) |
4437a0d2 | 129 | , fUsedEdx(kFALSE) |
809a4336 | 130 | { |
131 | // | |
132 | // Copy constructor | |
133 | // | |
134 | ref.Copy(*this); | |
135 | } | |
136 | ||
137 | //___________________________________________________________________ | |
138 | AliHFEpidTPC &AliHFEpidTPC::operator=(const AliHFEpidTPC &ref){ | |
139 | // | |
140 | // Assignment operator | |
141 | // | |
142 | if(this != &ref){ | |
143 | ref.Copy(*this); | |
144 | } | |
145 | return *this; | |
146 | } | |
75d81601 | 147 | //___________________________________________________________________ |
809a4336 | 148 | void AliHFEpidTPC::Copy(TObject &o) const{ |
149 | // | |
150 | // Copy function | |
151 | // called in copy constructor and assigment operator | |
152 | // | |
153 | AliHFEpidTPC &target = dynamic_cast<AliHFEpidTPC &>(o); | |
154 | ||
959ea9d8 | 155 | target.fkEtaCorrection = fkEtaCorrection; |
156 | target.fkCentralityCorrection = fkCentralityCorrection; | |
38be5083 | 157 | target.fkEtaMeanCorrection = fkEtaMeanCorrection; |
158 | target.fkEtaWidthCorrection = fkEtaWidthCorrection; | |
159 | target.fkCentralityMeanCorrection = fkCentralityMeanCorrection; | |
160 | target.fkCentralityWidthCorrection = fkCentralityWidthCorrection; | |
809a4336 | 161 | target.fLineCrossingsEnabled = fLineCrossingsEnabled; |
e156c3bb | 162 | target.fHasCutModel = fHasCutModel; |
cedf0381 | 163 | target.fUseOnlyOROC = fUseOnlyOROC; |
809a4336 | 164 | target.fNsigmaTPC = fNsigmaTPC; |
0792aa82 | 165 | target.fRejectionEnabled = fRejectionEnabled; |
e156c3bb | 166 | |
167 | memcpy(target.fkUpperSigmaCut, fkUpperSigmaCut, sizeof(const TF1 *) * 12); | |
168 | memcpy(target.fkLowerSigmaCut, fkLowerSigmaCut, sizeof(const TF1 *) * 12); | |
169 | ||
75d81601 | 170 | memcpy(target.fLineCrossingSigma, fLineCrossingSigma, sizeof(Double_t) * AliPID::kSPECIES); |
722347d8 | 171 | memcpy(target.fPAsigCut, fPAsigCut, sizeof(Float_t) * 2); |
172 | memcpy(target.fNAsigmaTPC, fNAsigmaTPC, sizeof(Float_t) * 2); | |
173 | ||
809a4336 | 174 | AliHFEpidBase::Copy(target); |
175 | } | |
176 | ||
177 | //___________________________________________________________________ | |
178 | AliHFEpidTPC::~AliHFEpidTPC(){ | |
179 | // | |
180 | // Destructor | |
181 | // | |
809a4336 | 182 | } |
183 | ||
184 | //___________________________________________________________________ | |
8c1c76e9 | 185 | Bool_t AliHFEpidTPC::InitializePID(Int_t /*run*/){ |
809a4336 | 186 | // |
187 | // Add TPC dE/dx Line crossings | |
188 | // | |
75d81601 | 189 | //AddTPCdEdxLineCrossing(AliPID::kKaon, 0.3, 0.018); |
190 | //AddTPCdEdxLineCrossing(AliPID::kProton, 0.9, 0.054); | |
809a4336 | 191 | return kTRUE; |
192 | } | |
193 | ||
194 | //___________________________________________________________________ | |
6555e2ad | 195 | Int_t AliHFEpidTPC::IsSelected(const AliHFEpidObject *track, AliHFEpidQAmanager *pidqa) const |
809a4336 | 196 | { |
197 | // | |
198 | // For the TPC pid we use the 2-sigma band around the bethe bloch curve | |
199 | // for electrons | |
200 | // exclusion of the crossing points | |
201 | // | |
3a72645a | 202 | |
8c1c76e9 | 203 | if(!fkPIDResponse) return 0; |
11ff28c5 | 204 | |
205 | AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis; | |
206 | ||
207 | // Make clone track in order to be able to apply correction | |
208 | const AliVTrack *rectrack; | |
209 | AliESDtrack esdtrack; | |
210 | AliAODTrack aodtrack; | |
38be5083 | 211 | Double_t correctedTPCnSigma=0.; |
212 | Bool_t TPCnSigmaCorrected=kFALSE; | |
213 | if((fkEtaMeanCorrection&&fkEtaWidthCorrection)|| | |
214 | (fkCentralityMeanCorrection&&fkCentralityWidthCorrection)){ | |
215 | TPCnSigmaCorrected=kTRUE; | |
216 | correctedTPCnSigma=GetCorrectedTPCnSigma(track->GetRecTrack()->Eta(), track->GetMultiplicity(), fkPIDResponse->NumberOfSigmasTPC(track->GetRecTrack(), AliPID::kElectron)); | |
217 | } | |
1a319cb5 | 218 | // jpsi |
219 | if((fkCentralityEtaCorrectionMeanJpsi)&& | |
220 | (fkCentralityEtaCorrectionWidthJpsi)){ | |
221 | TPCnSigmaCorrected=kTRUE; | |
222 | correctedTPCnSigma=GetCorrectedTPCnSigmaJpsi(track->GetRecTrack()->Eta(), track->GetMultiplicity(), fkPIDResponse->NumberOfSigmasTPC(track->GetRecTrack(), AliPID::kElectron)); | |
223 | } | |
959ea9d8 | 224 | if(fkEtaCorrection || fkCentralityCorrection){ |
11ff28c5 | 225 | // Correction available |
226 | // apply it on copy | |
227 | if(track->IsESDanalysis()){ | |
228 | esdtrack.~AliESDtrack(); | |
229 | new(&esdtrack) AliESDtrack(*(static_cast<const AliESDtrack *>(track->GetRecTrack()))); | |
959ea9d8 | 230 | if(track->IsPbPb() && HasCentralityCorrection()) |
231 | ApplyCentralityCorrection(&esdtrack, track->GetMultiplicity(), anatype); | |
232 | if(HasEtaCorrection()) | |
233 | ApplyEtaCorrection(&esdtrack, anatype); | |
11ff28c5 | 234 | rectrack = &esdtrack; |
235 | } else { | |
236 | aodtrack.~AliAODTrack(); | |
237 | new(&aodtrack) AliAODTrack(*(static_cast<const AliAODTrack *>(track->GetRecTrack()))); | |
959ea9d8 | 238 | if(track->IsPbPb() && HasCentralityCorrection()) |
239 | ApplyCentralityCorrection(&aodtrack, track->GetMultiplicity(), anatype); | |
240 | if(HasEtaCorrection()) | |
241 | ApplyEtaCorrection(&aodtrack, anatype); | |
11ff28c5 | 242 | rectrack = &aodtrack; |
243 | } | |
244 | } else { | |
245 | // Correction not available - no need to copy | |
246 | rectrack = track->GetRecTrack(); | |
247 | } | |
248 | AliHFEpidObject tpctrack(*track); | |
249 | tpctrack.SetRecTrack(rectrack); | |
38be5083 | 250 | if(TPCnSigmaCorrected)tpctrack.SetCorrectedTPCnSigma(correctedTPCnSigma); |
3a72645a | 251 | |
11ff28c5 | 252 | // QA before selection (after correction) |
253 | if(pidqa) pidqa->ProcessTrack(&tpctrack, AliHFEpid::kTPCpid, AliHFEdetPIDqa::kBeforePID); | |
e3fc062d | 254 | AliDebug(1, "Doing TPC PID based on n-Sigma cut approach"); |
11ff28c5 | 255 | |
256 | // make copy of the track in order to allow for applying the correction | |
38be5083 | 257 | Float_t nsigma=correctedTPCnSigma; |
258 | if(!TPCnSigmaCorrected) | |
259 | nsigma = fUsedEdx ? rectrack->GetTPCsignal() : fkPIDResponse->NumberOfSigmasTPC(rectrack, AliPID::kElectron); | |
3a72645a | 260 | AliDebug(1, Form("TPC NSigma: %f", nsigma)); |
809a4336 | 261 | // exclude crossing points: |
262 | // Determine the bethe values for each particle species | |
809a4336 | 263 | Bool_t isLineCrossing = kFALSE; |
264 | for(Int_t ispecies = 0; ispecies < AliPID::kSPECIES; ispecies++){ | |
75d81601 | 265 | if(ispecies == AliPID::kElectron) continue; |
809a4336 | 266 | if(!(fLineCrossingsEnabled & 1 << ispecies)) continue; |
11ff28c5 | 267 | if(TMath::Abs(fkPIDResponse->NumberOfSigmasTPC(rectrack, (AliPID::EParticleType)ispecies)) < fLineCrossingSigma[ispecies] && TMath::Abs(nsigma) < fNsigmaTPC){ |
9bcfd1ab | 268 | // Point in a line crossing region, no PID possible, but !PID still possible ;-) |
70da6c5a | 269 | isLineCrossing = kTRUE; |
809a4336 | 270 | break; |
271 | } | |
272 | } | |
273 | if(isLineCrossing) return 0; | |
0792aa82 | 274 | |
275 | // Check particle rejection | |
276 | if(HasParticleRejection()){ | |
11ff28c5 | 277 | Int_t reject = Reject(rectrack, anatype); |
0792aa82 | 278 | if(reject != 0) return reject; |
279 | } | |
722347d8 | 280 | |
faee3b18 | 281 | // Check if we have an asymmetric sigma model set |
0792aa82 | 282 | Int_t pdg = 0; |
e156c3bb | 283 | if(fHasCutModel){ |
11ff28c5 | 284 | pdg = CutSigmaModel(&tpctrack) ? 11 : 0; |
faee3b18 | 285 | } else { |
286 | // Perform Asymmetric n-sigma cut if required, else perform symmetric TPC sigma cut | |
5cd679b7 | 287 | Float_t p = rectrack->P(); |
288 | if(HasAsymmetricSigmaCut()) { | |
289 | ||
290 | //printf("p %f, fPAsigCut[0] %f, fPAsigCut[1] %f\n",p,fPAsigCut[0],fPAsigCut[1]); | |
291 | if(p >= fPAsigCut[0] && p <= fPAsigCut[1]) { | |
4437a0d2 | 292 | if(nsigma >= fNAsigmaTPC[0] && nsigma <= fNAsigmaTPC[1]) pdg = 11; |
293 | else pdg = 0; | |
5cd679b7 | 294 | } |
295 | else pdg = 0; | |
296 | ||
297 | } | |
298 | else { | |
faee3b18 | 299 | if(TMath::Abs(nsigma) < fNsigmaTPC ) pdg = 11; |
300 | } | |
70da6c5a | 301 | } |
11ff28c5 | 302 | if(pidqa && pdg != 0) pidqa->ProcessTrack(&tpctrack, AliHFEpid::kTPCpid, AliHFEdetPIDqa::kAfterPID); |
0792aa82 | 303 | return pdg; |
722347d8 | 304 | |
809a4336 | 305 | } |
306 | ||
faee3b18 | 307 | //___________________________________________________________________ |
e156c3bb | 308 | Bool_t AliHFEpidTPC::CutSigmaModel(const AliHFEpidObject * const track) const { |
faee3b18 | 309 | // |
310 | // N SigmaCut using parametrization of the cuts | |
311 | // | |
312 | Bool_t isSelected = kTRUE; | |
e156c3bb | 313 | AliHFEpidObject::AnalysisType_t anatype = track->IsESDanalysis() ? AliHFEpidObject::kESDanalysis : AliHFEpidObject::kAODanalysis; |
4437a0d2 | 314 | Float_t nsigma = fUsedEdx ? track->GetRecTrack()->GetTPCsignal() : fkPIDResponse->NumberOfSigmasTPC(track->GetRecTrack(), AliPID::kElectron); |
e156c3bb | 315 | Double_t p = GetP(track->GetRecTrack(), anatype); |
316 | Int_t centrality = track->IsPbPb() ? track->GetCentrality() + 1 : 0; | |
317 | AliDebug(2, Form("Centrality: %d\n", centrality)); | |
8c1c76e9 | 318 | if(centrality > 11) return kFALSE; |
e156c3bb | 319 | const TF1 *cutfunction; |
320 | if((cutfunction = fkUpperSigmaCut[centrality]) && nsigma > cutfunction->Eval(p)) isSelected = kFALSE; | |
321 | if((cutfunction = fkLowerSigmaCut[centrality]) && nsigma < cutfunction->Eval(p)) isSelected = kFALSE; | |
faee3b18 | 322 | return isSelected; |
323 | } | |
324 | ||
0792aa82 | 325 | //___________________________________________________________________ |
6555e2ad | 326 | Int_t AliHFEpidTPC::Reject(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anaType) const{ |
0792aa82 | 327 | // |
328 | // reject particles based on asymmetric sigma cut | |
329 | // | |
330 | Int_t pdc[AliPID::kSPECIES] = {11,13,211,321,2212}; | |
6555e2ad | 331 | Double_t p = GetP(track, anaType); |
0792aa82 | 332 | for(Int_t ispec = 0; ispec < AliPID::kSPECIES; ispec++){ |
333 | if(!TESTBIT(fRejectionEnabled, ispec)) continue; | |
0792aa82 | 334 | // Particle rejection enabled |
335 | if(p < fRejection[4*ispec] || p > fRejection[4*ispec+2]) continue; | |
8c1c76e9 | 336 | Double_t sigma = fkPIDResponse->NumberOfSigmasTPC(track, static_cast<AliPID::EParticleType>(ispec)); |
0792aa82 | 337 | if(sigma >= fRejection[4*ispec+1] && sigma <= fRejection[4*ispec+3]) return pdc[ispec] * track->Charge(); |
338 | } | |
339 | return 0; | |
340 | } | |
341 | ||
11ff28c5 | 342 | //___________________________________________________________________ |
343 | void AliHFEpidTPC::ApplyEtaCorrection(AliVTrack *track, AliHFEpidObject::AnalysisType_t anatype) const{ | |
344 | // | |
345 | // Apply correction for the eta dependence | |
346 | // N.B. This correction has to be applied on a copy track | |
347 | // | |
348 | AliDebug(1, Form("Applying correction function %s\n", fkEtaCorrection->GetName())); | |
349 | Double_t original = track->GetTPCsignal(), | |
350 | eta = track->Eta(); | |
351 | if(anatype == AliHFEpidObject::kESDanalysis){ | |
352 | AliESDtrack *esdtrack = static_cast<AliESDtrack *>(track); | |
959ea9d8 | 353 | if(fkEtaCorrection->Eval(eta)>0.0) esdtrack->SetTPCsignal(original/fkEtaCorrection->Eval(eta), esdtrack->GetTPCsignalSigma(), esdtrack->GetTPCsignalN()); |
11ff28c5 | 354 | } else { |
355 | AliAODTrack *aodtrack = static_cast<AliAODTrack *>(track); | |
356 | AliAODPid *pid = aodtrack->GetDetPid(); | |
959ea9d8 | 357 | if(pid && fkEtaCorrection->Eval(eta)>0.0) pid->SetTPCsignal(original/fkEtaCorrection->Eval(eta)); |
11ff28c5 | 358 | } |
359 | } | |
959ea9d8 | 360 | |
361 | //___________________________________________________________________ | |
362 | void AliHFEpidTPC::ApplyCentralityCorrection(AliVTrack *track, Double_t centralityEstimator, AliHFEpidObject::AnalysisType_t anatype) const{ | |
363 | // | |
364 | // Apply correction for the eta dependence | |
365 | // N.B. This correction has to be applied on a copy track | |
366 | // | |
367 | AliDebug(1, Form("Applying correction function %s\n", fkCentralityCorrection->GetName())); | |
368 | Double_t original = track->GetTPCsignal(); | |
369 | if(anatype == AliHFEpidObject::kESDanalysis){ | |
370 | AliESDtrack *esdtrack = static_cast<AliESDtrack *>(track); | |
371 | if(fkCentralityCorrection->Eval(centralityEstimator)>0.0) esdtrack->SetTPCsignal(original/fkCentralityCorrection->Eval(centralityEstimator), esdtrack->GetTPCsignalSigma(), esdtrack->GetTPCsignalN()); | |
372 | } else { | |
373 | AliAODTrack *aodtrack = static_cast<AliAODTrack *>(track); | |
374 | AliAODPid *pid = aodtrack->GetDetPid(); | |
375 | if(pid && fkCentralityCorrection->Eval(centralityEstimator)>0.0) pid->SetTPCsignal(original/fkCentralityCorrection->Eval(centralityEstimator)); | |
376 | } | |
377 | } | |
378 | ||
38be5083 | 379 | //___________________________________________________________________ |
380 | Double_t AliHFEpidTPC::GetCorrectedTPCnSigma(Double_t eta, Double_t centralityEstimator, Double_t tpcNsigma) const{ | |
381 | // | |
382 | // Apply correction for the eta dependence | |
383 | // N.B. This correction has to be applied on a copy track | |
384 | // | |
385 | Double_t corrtpcNsigma = tpcNsigma; | |
38be5083 | 386 | if(fkEtaMeanCorrection&&fkEtaWidthCorrection){ |
387 | if(TMath::Abs(fkEtaWidthCorrection->Eval(eta))>0.0000001) corrtpcNsigma=(corrtpcNsigma-fkEtaMeanCorrection->Eval(eta))/fkEtaWidthCorrection->Eval(eta); | |
388 | } | |
389 | if(fkCentralityMeanCorrection&&fkCentralityWidthCorrection) { | |
390 | if(TMath::Abs(fkCentralityWidthCorrection->Eval(centralityEstimator))>0.0000001) corrtpcNsigma=(corrtpcNsigma-fkCentralityMeanCorrection->Eval(centralityEstimator))/fkCentralityWidthCorrection->Eval(centralityEstimator); | |
391 | } | |
392 | return corrtpcNsigma; | |
393 | } | |
394 | ||
1a319cb5 | 395 | //___________________________________________________________________ |
396 | Double_t AliHFEpidTPC::GetCorrectedTPCnSigmaJpsi(Double_t eta, Double_t centralityEstimator, Double_t tpcNsigma) const{ | |
397 | // | |
398 | // Apply correction for the eta dependence | |
399 | // N.B. This correction has to be applied on a copy track | |
400 | // | |
401 | Double_t corrtpcNsigma = tpcNsigma; | |
402 | if(fkCentralityEtaCorrectionMeanJpsi&&fkCentralityEtaCorrectionWidthJpsi){ | |
13d6113d | 403 | const TAxis *caxis = fkCentralityEtaCorrectionMeanJpsi->GetXaxis(); |
404 | const TAxis *eaxis = fkCentralityEtaCorrectionMeanJpsi->GetYaxis(); | |
405 | Int_t cbin = caxis->FindFixBin(centralityEstimator); | |
406 | Int_t ebin = eaxis->FindFixBin(eta); | |
562897a9 | 407 | //Double_t cbinlowedge = caxis->GetBinLowEdge(cbin); |
408 | //Double_t cbinupedge = caxis->GetBinUpEdge(cbin); | |
409 | //Double_t ebinlowedge = eaxis->GetBinLowEdge(ebin); | |
410 | //Double_t ebinupedge = eaxis->GetBinUpEdge(ebin); | |
1a319cb5 | 411 | Double_t center = fkCentralityEtaCorrectionMeanJpsi->GetBinContent(cbin,ebin); |
412 | Double_t width = fkCentralityEtaCorrectionWidthJpsi->GetBinContent(cbin,ebin); | |
413 | //printf("cbin %d, cbinlowe %f, cbinupe %f, centrality %f\n",cbin,cbinlowedge,cbinupedge,centralityEstimator); | |
414 | //printf("ebin %d, ebinlowe %f, ebinupe %f, eta %f\n",ebin,ebinlowedge,ebinupedge,eta); | |
415 | //printf("mean %f, width %f\n",center,width); | |
416 | if(TMath::Abs(width)>0.0000001) corrtpcNsigma=(corrtpcNsigma-center)/width; | |
417 | } | |
418 | return corrtpcNsigma; | |
419 | } | |
420 | ||
cedf0381 | 421 | //___________________________________________________________________ |
422 | void AliHFEpidTPC::UseOROC(AliVTrack *track, AliHFEpidObject::AnalysisType_t anatype) const{ | |
423 | // | |
424 | // Use TPC signal from the OROC | |
425 | // N.B. This correction has to be applied on a copy track | |
426 | // | |
427 | //Double_t original = track->GetTPCsignal(); | |
428 | ||
429 | if(anatype == AliHFEpidObject::kESDanalysis){ | |
430 | AliESDtrack *esdtrack = static_cast<AliESDtrack *>(track); | |
431 | AliTPCdEdxInfo *dEdxInfo = track->GetTPCdEdxInfo(); | |
432 | Double32_t TPCsignalRegion[4]; // TPC dEdx signal in 4 different regions - 0 - IROC, 1- OROC medium, 2 - OROC long, 3- OROC all, (default truncation used) | |
433 | Char_t TPCsignalNRegion[3]; // number of clusters above threshold used in the dEdx calculation | |
434 | Char_t TPCsignalNRowRegion[3]; // number of crosed rows used in the dEdx calculation - signal below threshold included | |
435 | dEdxInfo->GetTPCSignalRegionInfo(TPCsignalRegion,TPCsignalNRegion,TPCsignalNRowRegion); | |
436 | esdtrack->SetTPCsignal(TPCsignalRegion[3],esdtrack->GetTPCsignalSigma(),(TPCsignalNRegion[1]+TPCsignalNRegion[2])); // the two last are not ok | |
437 | } else { | |
438 | AliAODTrack *aodtrack = static_cast<AliAODTrack *>(track); | |
439 | AliTPCdEdxInfo *dEdxInfo = track->GetTPCdEdxInfo(); | |
440 | Double32_t TPCsignalRegion[4]; // TPC dEdx signal in 4 different regions - 0 - IROC, 1- OROC medium, 2 - OROC long, 3- OROC all, (default truncation used) | |
441 | Char_t TPCsignalNRegion[3]; // number of clusters above threshold used in the dEdx calculation | |
442 | Char_t TPCsignalNRowRegion[3]; // number of crosed rows used in the dEdx calculation - signal below threshold included | |
443 | dEdxInfo->GetTPCSignalRegionInfo(TPCsignalRegion,TPCsignalNRegion,TPCsignalNRowRegion); | |
444 | AliAODPid *pid = aodtrack->GetDetPid(); | |
445 | if(pid) pid->SetTPCsignal(TPCsignalRegion[3]); | |
446 | if(pid) pid->SetTPCsignalN((TPCsignalNRegion[1]+TPCsignalNRegion[2])); | |
447 | } | |
11ff28c5 | 448 | |
cedf0381 | 449 | } |
809a4336 | 450 | //___________________________________________________________________ |
75d81601 | 451 | void AliHFEpidTPC::AddTPCdEdxLineCrossing(Int_t species, Double_t sigma){ |
809a4336 | 452 | // |
453 | // Add exclusion point for the TPC PID where a dEdx line crosses the electron line | |
454 | // Stores line center and line sigma | |
455 | // | |
456 | if(species >= AliPID::kSPECIES){ | |
457 | AliError("Species doesn't exist"); | |
458 | return; | |
459 | } | |
460 | fLineCrossingsEnabled |= 1 << species; | |
75d81601 | 461 | fLineCrossingSigma[species] = sigma; |
809a4336 | 462 | } |
463 | ||
6555e2ad | 464 | //___________________________________________________________________ |
465 | Double_t AliHFEpidTPC::GetP(const AliVParticle *track, AliHFEpidObject::AnalysisType_t anatype) const { | |
466 | // | |
467 | // Get the momentum at the inner wall of the TPC | |
468 | // | |
469 | Double_t p = -1; | |
470 | if(anatype == AliHFEpidObject::kESDanalysis){ | |
471 | // ESD analysis: Use Inner Params for the momentum estimate | |
472 | const AliESDtrack *esdtrack = dynamic_cast<const AliESDtrack *>(track); | |
bf892a6a | 473 | if(esdtrack) p = esdtrack->GetInnerParam() ? esdtrack->GetInnerParam()->GetP() : esdtrack->P(); |
58d0bf42 | 474 | } |
475 | ||
476 | if(anatype == AliHFEpidObject::kAODanalysis) | |
477 | { | |
6555e2ad | 478 | // AOD analysis: Use TPC momentum stored in the AliAODpid object |
479 | const AliAODTrack *aodtrack = dynamic_cast<const AliAODTrack *>(track); | |
bf892a6a | 480 | if(aodtrack) p = aodtrack->GetDetPid() ? aodtrack->GetDetPid()->GetTPCmomentum() : aodtrack->P(); |
6555e2ad | 481 | } |
482 | return p; | |
483 | } |