]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGDQ/dielectron/AliDielectronPID.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
updated
[u/mrichter/AliRoot.git] / PWGDQ / dielectron / AliDielectronPID.cxx
CommitLineData
8df8e382 1/*************************************************************************
2* Copyright(c) 1998-2009, 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///////////////////////////////////////////////////////////////////////////
17// Dielectron PID //
18// //
19// //
20/*
21Detailed description
22
23
24*/
25// //
26///////////////////////////////////////////////////////////////////////////
27
28#include <TMath.h>
29#include <TF1.h>
48609e3d 30#include <TGraph.h>
8df8e382 31
164bfb53 32#include <AliVTrack.h>
5720c765 33#include <AliVCluster.h>
8df8e382 34#include <AliLog.h>
ffbede40 35#include <AliExternalTrackParam.h>
5720c765 36#include <AliPIDResponse.h>
6d5dea7c 37#include <AliTRDPIDResponse.h>
5720c765 38#include <AliESDtrack.h> //!!!!! Remove once Eta correction is treated in the tender
0c09cae4 39#include <AliAODTrack.h>
40#include <AliAODPid.h>
8df8e382 41
42#include "AliDielectronVarManager.h"
43
44#include "AliDielectronPID.h"
45
46ClassImp(AliDielectronPID)
47
48609e3d 48TGraph *AliDielectronPID::fgFitCorr=0x0;
49Double_t AliDielectronPID::fgCorr=0.0;
d327d9cd 50Double_t AliDielectronPID::fgCorrdEdx=1.0;
5720c765 51TF1 *AliDielectronPID::fgFunEtaCorr=0x0;
d327d9cd 52TGraph *AliDielectronPID::fgdEdxRunCorr=0x0;
48609e3d 53
8df8e382 54AliDielectronPID::AliDielectronPID() :
55 AliAnalysisCuts(),
56 fNcuts(0),
5720c765 57 fPIDResponse(0x0)
8df8e382 58{
59 //
60 // Default Constructor
61 //
62 for (Int_t icut=0; icut<kNmaxPID; ++icut){
63 fDetType[icut]=kTPC;
64 fPartType[icut]=AliPID::kPion;
65 fNsigmaLow[icut]=0;
66 fNsigmaUp[icut]=0;
5720c765 67 fmin[icut]=0;
68 fmax[icut]=0;
8df8e382 69 fExclude[icut]=kFALSE;
70 fFunUpperCut[icut]=0x0;
71 fFunLowerCut[icut]=0x0;
61d106d3 72 fRequirePIDbit[icut]=0;
5720c765 73 fActiveCuts[icut]=-1;
88204efa 74 fSigmaFunLow[icut]=0;
75 fSigmaFunUp[icut]=0;
76 fFunSigma[icut]=0x0;
8df8e382 77 }
78}
79
80//______________________________________________
81AliDielectronPID::AliDielectronPID(const char* name, const char* title) :
82 AliAnalysisCuts(name, title),
83 fNcuts(0),
5720c765 84 fPIDResponse(0x0)
8df8e382 85{
86 //
87 // Named Constructor
88 //
89 for (Int_t icut=0; icut<kNmaxPID; ++icut){
90 fDetType[icut]=kTPC;
91 fPartType[icut]=AliPID::kPion;
92 fNsigmaLow[icut]=0;
93 fNsigmaUp[icut]=0;
5720c765 94 fmin[icut]=0;
95 fmax[icut]=0;
8df8e382 96 fExclude[icut]=kFALSE;
97 fFunUpperCut[icut]=0x0;
98 fFunLowerCut[icut]=0x0;
61d106d3 99 fRequirePIDbit[icut]=0;
5720c765 100 fActiveCuts[icut]=0;
88204efa 101 fSigmaFunLow[icut]=0;
102 fSigmaFunUp[icut]=0;
103 fFunSigma[icut]=0x0;
8df8e382 104 }
105}
106
107//______________________________________________
108AliDielectronPID::~AliDielectronPID()
109{
110 //
111 // Default Destructor
112 //
113}
114
115//______________________________________________
116void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, Double_t nSigmaUp/*=-99999.*/,
5720c765 117 Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
118 UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
8df8e382 119{
120 //
121 // Add a pid nsigma cut
5720c765 122 // use response of detector 'det' in the range ['min'] to ['max'] for var
123 // use a sigma band between 'nSigmaLow' and 'nSigmaUp'
8df8e382 124 // if nSigmaUp==-99999. then nSigmaLow will be uesd as a symmetric band +- nSigmaLow
125 // specify whether to 'exclude' the given band
126 //
127
45b2b1b8 128 if (fNcuts>=kNmaxPID){
8df8e382 129 AliError(Form("only %d pid cut ranges allowed",kNmaxPID));
45b2b1b8 130 return;
8df8e382 131 }
132 if (TMath::Abs(nSigmaUp+99999.)<1e-20){
133 nSigmaUp=TMath::Abs(nSigmaLow);
134 nSigmaLow=-1.*nSigmaUp;
135 }
136 fDetType[fNcuts]=det;
137 fPartType[fNcuts]=type;
138 fNsigmaLow[fNcuts]=nSigmaLow;
139 fNsigmaUp[fNcuts]=nSigmaUp;
5720c765 140 fmin[fNcuts]=min;
141 fmax[fNcuts]=max;
8df8e382 142 fExclude[fNcuts]=exclude;
61d106d3 143 fRequirePIDbit[fNcuts]=pidBitType;
5720c765 144 fActiveCuts[fNcuts]=(var==-1 ? AliDielectronVarManager::kP : var);
145
fd6ebd85 146 AliDebug(1,Form("Add PID cut %d: sigma [% .1f,% .1f] \t cut [% .1f,% .f] \t var %d->%s \n",
147 fNcuts,nSigmaLow,nSigmaUp,min,max,fActiveCuts[fNcuts],AliDielectronVarManager::GetValueName(fActiveCuts[fNcuts])));
8df8e382 148
5720c765 149 ++fNcuts;
150
8df8e382 151}
152
153//______________________________________________
154void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, TF1 * const funUp,
5720c765 155 Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
156 UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
8df8e382 157{
158 //
159 // cut using a TF1 as upper cut
160 //
161 if (funUp==0x0){
162 AliError("A valid function is required for the upper cut. Not adding the cut!");
163 return;
164 }
165 fFunUpperCut[fNcuts]=funUp;
5720c765 166 AddCut(det,type,nSigmaLow,0.,min,max,exclude,pidBitType,var);
8df8e382 167}
168
169//______________________________________________
170void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, TF1 * const funLow, Double_t nSigmaUp,
5720c765 171 Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
172 UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
8df8e382 173{
174 //
175 // cut using a TF1 as lower cut
176 //
177 if (funLow==0x0){
178 AliError("A valid function is required for the lower cut. Not adding the cut!");
179 return;
180 }
181 fFunLowerCut[fNcuts]=funLow;
5720c765 182 AddCut(det,type,0.,nSigmaUp,min,max,exclude,pidBitType,var);
8df8e382 183}
184
185//______________________________________________
186void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, TF1 * const funLow, TF1 * const funUp,
5720c765 187 Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
188 UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
8df8e382 189{
190 //
191 // cut using a TF1 as lower and upper cut
192 //
193 if ( (funUp==0x0) || (funLow==0x0) ){
194 AliError("A valid function is required for upper and lower cut. Not adding the cut!");
195 return;
196 }
197 fFunUpperCut[fNcuts]=funUp;
198 fFunLowerCut[fNcuts]=funLow;
5720c765 199 AddCut(det,type,0.,0.,min,max,exclude,pidBitType,var);
8df8e382 200}
201
88204efa 202//______________________________________________
203void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, Double_t nSigmaUp,
204 Double_t min, Double_t max, Bool_t exclude,
205 UInt_t pidBitType, TF1 * const funSigma)
206{
207 //
208 // cut using a TF1 as lower cut
209 //
210 if (funSigma==0x0){
211 AliError("A valid function is required for the sigma cut. Not adding the cut!");
212 return;
213 }
214 fFunSigma[fNcuts]=funSigma;
215 fSigmaFunLow[fNcuts]=min;
216 fSigmaFunUp[fNcuts]=max;
217
218 AddCut(det,type,nSigmaLow,nSigmaUp,0,0,exclude,pidBitType,-1);
219}
220
8df8e382 221//______________________________________________
222Bool_t AliDielectronPID::IsSelected(TObject* track)
223{
224 //
225 // perform PID cuts
226 //
227
228 //loop over all cuts
164bfb53 229 AliVTrack *part=static_cast<AliVTrack*>(track);
5720c765 230 AliESDtrack *esdTrack=0x0;
0c09cae4 231 AliAODTrack *aodTrack=0x0;
5720c765 232 Double_t origdEdx=-1;
8df8e382 233
5720c765 234 // apply ETa correction, remove once this is in the tender
0c09cae4 235 if( (part->IsA() == AliESDtrack::Class()) ){
5720c765 236 esdTrack=static_cast<AliESDtrack*>(part);
237 origdEdx=esdTrack->GetTPCsignal();
d327d9cd 238 esdTrack->SetTPCsignal(origdEdx/GetEtaCorr(esdTrack)/fgCorrdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
0c09cae4 239 } else if ( (part->IsA() == AliAODTrack::Class()) ){
240 aodTrack=static_cast<AliAODTrack*>(track);
241 AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
423cc7ef 242 if (pid){
243 origdEdx=pid->GetTPCsignal();
244 pid->SetTPCsignal(origdEdx/GetEtaCorr(aodTrack)/fgCorrdEdx);
245 }
5720c765 246 }
5720c765 247
248 //Fill values
249 Double_t values[AliDielectronVarManager::kNMaxValues];
250 AliDielectronVarManager::Fill(track,values);
8df8e382 251
5720c765 252 Bool_t selected=kFALSE;
253 fPIDResponse=AliDielectronVarManager::GetPIDResponse();
254 for (UChar_t icut=0; icut<fNcuts; ++icut){
255 Double_t min=fmin[icut];
256 Double_t max=fmax[icut];
257 Double_t val=values[fActiveCuts[icut]];
258
259 // test var range. In case min==max do not cut
260 if ( (TMath::Abs(min-max)>1e-20) && (val<min || val>=max) ) continue;
88204efa 261
262
263 // check if fFunSigma is set, then check if 'part' is in sigma range of the function
264 if(fFunSigma[icut]){
265 val= fPIDResponse->NumberOfSigmasTPC(part, fPartType[icut]);
266 if (fPartType[icut]==AliPID::kElectron){
267 val-=fgCorr;
268 }
269 min= fFunSigma[icut]->Eval(part->GetTPCmomentum())+fSigmaFunLow[icut];
270 max= fFunSigma[icut]->Eval(part->GetTPCmomentum())+fSigmaFunUp[icut];
271 if(val<min || val>=max) continue;
272 }
273
8df8e382 274 switch (fDetType[icut]){
275 case kITS:
276 selected = IsSelectedITS(part,icut);
277 break;
278 case kTPC:
279 selected = IsSelectedTPC(part,icut);
280 break;
281 case kTRD:
282 selected = IsSelectedTRD(part,icut);
283 break;
5720c765 284 case kTRDeleEff:
285 selected = IsSelectedTRDeleEff(part,icut);
286 break;
6d5dea7c 287 case kTRDeleEff2D:
288 selected = IsSelectedTRDeleEff(part,icut,AliTRDPIDResponse::kLQ2D);
289 break;
8df8e382 290 case kTOF:
291 selected = IsSelectedTOF(part,icut);
292 break;
5720c765 293 case kEMCAL:
294 selected = IsSelectedEMCAL(part,icut);
295 break;
296 }
297 if (!selected) {
298 if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
0c09cae4 299 else if (aodTrack){
300 AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
423cc7ef 301 if (pid) pid->SetTPCsignal(origdEdx);
0c09cae4 302 }
5720c765 303
304 return kFALSE;
8df8e382 305 }
8df8e382 306 }
307
5720c765 308 if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
0c09cae4 309 else if (aodTrack){
310 AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
423cc7ef 311 if (pid) pid->SetTPCsignal(origdEdx);
0c09cae4 312 }
8df8e382 313 return selected;
314}
315
316//______________________________________________
ffbede40 317Bool_t AliDielectronPID::IsSelectedITS(AliVTrack * const part, Int_t icut)
8df8e382 318{
319 //
320 // ITS part of the PID check
321 // Don't accept the track if there was no pid bit set
322 //
8df8e382 323
5720c765 324 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kITSpid)) return kFALSE;
325 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kITSpid)) return kTRUE;
ffbede40 326
327 Double_t mom=part->P();
164bfb53 328
5720c765 329 Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasITS(part, fPartType[icut]);
ffbede40 330
331 // test if we are supposed to use a function for the cut
332 if (fFunUpperCut[icut]) fNsigmaUp[icut] =fFunUpperCut[icut]->Eval(mom);
333 if (fFunLowerCut[icut]) fNsigmaLow[icut]=fFunLowerCut[icut]->Eval(mom);
334
8df8e382 335 Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
336 return selected;
337}
338
339//______________________________________________
ffbede40 340Bool_t AliDielectronPID::IsSelectedTPC(AliVTrack * const part, Int_t icut)
8df8e382 341{
342 //
343 // TPC part of the PID check
344 // Don't accept the track if there was no pid bit set
345 //
5720c765 346 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kTPCpid)) return kFALSE;
347 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kTPCpid)) return kTRUE;
48609e3d 348
5720c765 349 Double_t mom=part->GetTPCmomentum();
ffbede40 350
5720c765 351 Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasTPC(part, fPartType[icut]);
352
2a14a7b1 353 if (fPartType[icut]==AliPID::kElectron){
354 numberOfSigmas-=fgCorr;
8df8e382 355 }
ffbede40 356
357 // test if we are supposed to use a function for the cut
358 if (fFunUpperCut[icut]) fNsigmaUp[icut] =fFunUpperCut[icut]->Eval(mom);
359 if (fFunLowerCut[icut]) fNsigmaLow[icut]=fFunLowerCut[icut]->Eval(mom);
360
8df8e382 361 Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
362 return selected;
363}
364
365//______________________________________________
5720c765 366Bool_t AliDielectronPID::IsSelectedTRD(AliVTrack * const part, Int_t icut)
8df8e382 367{
368 //
369 // TRD part of the pid check
5720c765 370 // the TRD checks on the probabilities.
371 //
372
373 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kTRDpid)) return kFALSE;
374 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kTRDpid)) return kTRUE;
375 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable && (part->GetTRDntrackletsPID()<4)) return kTRUE;
376
377 Double_t p[AliPID::kSPECIES]={0.};
378 fPIDResponse->ComputeTRDProbability(part,AliPID::kSPECIES,p);
379 Float_t particleProb=p[fPartType[icut]];
380
381 Bool_t selected=((particleProb>=fNsigmaLow[icut])&&(particleProb<=fNsigmaUp[icut]))^fExclude[icut];
382 return selected;
383}
384
385//______________________________________________
6d5dea7c 386Bool_t AliDielectronPID::IsSelectedTRDeleEff(AliVTrack * const part, Int_t icut, AliTRDPIDResponse::ETRDPIDMethod PIDmethod)
5720c765 387{
8df8e382 388 //
5720c765 389 // TRD part of the pid check using electron efficiency requirement
390 // in this case the upper limit as well as the particle specie is ignored
391 // and the lower limit regarded as the requested electron efficiency
392 //
393
394 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kTRDpid)) return kFALSE;
395 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kTRDpid)) return kTRUE;
396
6d5dea7c 397 Double_t centrality = -1.;
398 if(part->IsA() == AliESDtrack::Class())
399 centrality=(const_cast<AliESDEvent*>( (static_cast<const AliESDtrack*>(part))->GetESDEvent()) )->GetCentrality()->GetCentralityPercentile("V0M");
400 if(part->IsA() == AliAODTrack::Class())
401 centrality=(const_cast<AliAODEvent*>( (static_cast<const AliAODTrack*>(part))->GetAODEvent()) )->GetCentrality()->GetCentralityPercentile("V0M");
402
403 Bool_t selected=fPIDResponse->IdentifiedAsElectronTRD(part,fNsigmaLow[icut], centrality, PIDmethod)^fExclude[icut];
5720c765 404 return selected;
8df8e382 405}
406
407//______________________________________________
ffbede40 408Bool_t AliDielectronPID::IsSelectedTOF(AliVTrack * const part, Int_t icut)
8df8e382 409{
410 //
411 // TOF part of the PID check
412 // Don't accept the track if there was no pid bit set
413 //
8df8e382 414
5720c765 415 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kTOFpid)) return kFALSE;
416 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kTOFpid)) return kTRUE;
417
418 Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasTOF(part, fPartType[icut]);
8df8e382 419
420 Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
421 return selected;
422}
423
5720c765 424//______________________________________________
425Bool_t AliDielectronPID::IsSelectedEMCAL(AliVTrack * const part, Int_t icut)
426{
427 //
428 // emcal pid selecttion
429 //
430
431 //TODO: correct way to check for emcal pid?
432 Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasEMCAL(part, fPartType[icut]);
433
434 Bool_t hasPID=numberOfSigmas>-998.;
435
436 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!hasPID) return kFALSE;
437 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!hasPID) return kTRUE;
438
439
440 Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
441 return selected;
442}
443
8df8e382 444//______________________________________________
445void AliDielectronPID::SetDefaults(Int_t def){
446 //
447 // initialise default pid strategies
448 //
449
450 if (def==0){
451 // 2sigma bands TPC:
452 // - include e
453 // - exclude mu,K,pi,p
454 // -complete p range
455 AddCut(kTPC,AliPID::kElectron,2);
456 AddCut(kTPC,AliPID::kMuon,-2.,2.,0.,0.,kTRUE);
457 AddCut(kTPC,AliPID::kPion,-2.,2.,0.,0.,kTRUE);
458 AddCut(kTPC,AliPID::kKaon,-2.,2.,0.,0.,kTRUE);
459 AddCut(kTPC,AliPID::kProton,-2.,2.,0.,0.,kTRUE);
460 } else if (def==1) {
461 // 2sigma bands TPC:
462 // - include e 0<p<inf
463 // - exclude mu,K,pi,p 0<p<2
8df8e382 464 AddCut(kTPC,AliPID::kElectron,2.);
465 AddCut(kTPC,AliPID::kMuon,-2.,2.,0.,2.,kTRUE);
466 AddCut(kTPC,AliPID::kPion,-2.,2.,0.,2.,kTRUE);
467 AddCut(kTPC,AliPID::kKaon,-2.,2.,0.,2.,kTRUE);
468 AddCut(kTPC,AliPID::kProton,-2.,2.,0.,2.,kTRUE);
469
470 } else if (def==2) {
471 // include 2sigma e TPC
472 // 3sigma bands TOF
473 // - exclude K,P
48609e3d 474 AddCut(kTPC,AliPID::kElectron,-3.,3.);
3505bfad 475 AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
476 AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
8df8e382 477
5720c765 478 } else if (def==3 || def==4) { // def3 and def4 are the same??
8df8e382 479 // include 2sigma e TPC
480 // 3sigma bands TOF
481 // - exclude K 0<p<1
482 // - exclude P 0<p<2
483 AddCut(kTPC,AliPID::kElectron,2);
484 AddCut(kTOF,AliPID::kKaon,-3.,3.,0.,1.,kTRUE);
485 AddCut(kTOF,AliPID::kProton,-6.,6.,0.,1.,kTRUE);
486 AddCut(kTOF,AliPID::kProton,-3.,3.,1.,2.,kTRUE);
487
8df8e382 488 } else if (def==5) {
489 AddCut(kTPC,AliPID::kElectron,-0.5,3);
490 AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
491 } else if (def==6) {
492 // lower cut TPC: parametrisation by HFE
493 // upper cut TPC: 3 sigma
494 // TOF ele band 3sigma 0<p<1.5GeV
495 TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)", 0, 100);
496 lowerCut->SetParameters(-2.7,-0.4357);
497 AddCut(kTPC,AliPID::kElectron,lowerCut,3.);
498 AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
499 } else if (def==7) {
61d106d3 500 // wide TPC cut
8df8e382 501 // TOF ele band 3sigma 0<p<1.5GeV
502 AddCut(kTPC,AliPID::kElectron,10.);
503 AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
61d106d3 504 } else if (def==8) {
505 // TOF 5 sigma inclusion if TOFpid available
506 // this should reduce K,p,Pi to a large extent
507 AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
508 } else if (def==9) {
509 // lower cut TPC: parametrisation by HFE
510 // upper cut TPC: 3 sigma
511 // TOF 5 sigma inclusion if TOFpid available
512 // this should reduce K,p,Pi to a large extent
513 TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)", 0, 100);
164bfb53 514 lowerCut->SetParameters(-2.65,-0.6757);
515 AddCut(kTPC,AliPID::kElectron,lowerCut,4.);
61d106d3 516 AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
ba15fdfb 517
61d106d3 518 } else if (def==10) {
519 AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
520 AddCut(kTPC,AliPID::kElectron,3.);
521 AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
522 AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
523
ba15fdfb 524 } else if (def==11) {
525 // lower cut TPC: parametrisation by HFE
526 // only use from period d on !!
527 // upper cut TPC: 3 sigma
528 // TOF ele band 3sigma 0<p<2.0GeV
529 TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)+[2]", 0, 100);
530 lowerCut->SetParameters(-3.718,-0.4,0.27);
531 AddCut(kTPC,AliPID::kElectron,lowerCut,3.);
532 AddCut(kTOF,AliPID::kElectron,-3,3,0,2.);
533 } else if (def==12) {
534 // lower cut TPC: parametrisation by HFE
535 // only use from period d on !!
536 // upper cut TPC: 3 sigma
537 // TOF 5 sigma inclusion if TOFpid available
538 // this should reduce K,p,Pi to a large extent
539 TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)+[2]", 0, 100);
540 lowerCut->SetParameters(-3.718,-0.4,0.27);
541 AddCut(kTPC,AliPID::kElectron,lowerCut,4.);
542 AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
8df8e382 543 }
ba15fdfb 544
8df8e382 545}
546
48609e3d 547//______________________________________________
548void AliDielectronPID::SetCorrVal(Double_t run)
549{
550 //
551 // set correction value for run
552 //
d327d9cd 553 fgCorr=0.;
554 fgCorrdEdx=1.;
555
556 if (fgFitCorr){
557 fgCorr=fgFitCorr->Eval(run);
558 if (run<fgFitCorr->GetX()[0]) fgCorr=fgFitCorr->GetY()[0];
559 if (run>fgFitCorr->GetX()[fgFitCorr->GetN()-1]) fgCorr=fgFitCorr->GetY()[fgFitCorr->GetN()-1];
560 }
561
562 if (fgdEdxRunCorr){
563 fgCorrdEdx=fgdEdxRunCorr->Eval(run);
564 if (run<fgdEdxRunCorr->GetX()[0]) fgCorrdEdx=fgdEdxRunCorr->GetY()[0];
565 if (run>fgdEdxRunCorr->GetX()[fgFitCorr->GetN()-1]) fgCorrdEdx=fgdEdxRunCorr->GetY()[fgdEdxRunCorr->GetN()-1];
566 }
48609e3d 567}
568
5720c765 569//______________________________________________
0c09cae4 570Double_t AliDielectronPID::GetEtaCorr(const AliVTrack *track)
5720c765 571{
572 //
573 // return eta correction
574 //
575 if (!fgFunEtaCorr) return 1;
576 return fgFunEtaCorr->Eval(track->Eta());
577}