]> 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
update AddTask JetMass macros
[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"
8c2440d0 43#include "AliDielectronVarCuts.h"
8df8e382 44
45#include "AliDielectronPID.h"
46
47ClassImp(AliDielectronPID)
48
30f9a393 49TGraph *AliDielectronPID::fgFitCorr=0x0;
48609e3d 50Double_t AliDielectronPID::fgCorr=0.0;
d327d9cd 51Double_t AliDielectronPID::fgCorrdEdx=1.0;
30f9a393
JB		 52TF1 *AliDielectronPID::fgFunEtaCorr=0x0;
53TF1 *AliDielectronPID::fgFunCntrdCorr=0x0;
54TF1 *AliDielectronPID::fgFunWdthCorr=0x0;
55TGraph *AliDielectronPID::fgdEdxRunCorr=0x0;
48609e3d 56
8df8e382 57AliDielectronPID::AliDielectronPID() :
58 AliAnalysisCuts(),
59 fNcuts(0),
8d42b5b9 60 fPIDResponse(0x0)
8df8e382 61{
62 //
63 // Default Constructor
64 //
65 for (Int_t icut=0; icut<kNmaxPID; ++icut){
66 fDetType[icut]=kTPC;
67 fPartType[icut]=AliPID::kPion;
68 fNsigmaLow[icut]=0;
69 fNsigmaUp[icut]=0;
5720c765 70 fmin[icut]=0;
71 fmax[icut]=0;
8df8e382 72 fExclude[icut]=kFALSE;
73 fFunUpperCut[icut]=0x0;
74 fFunLowerCut[icut]=0x0;
61d106d3 75 fRequirePIDbit[icut]=0;
5720c765 76 fActiveCuts[icut]=-1;
88204efa 77 fSigmaFunLow[icut]=0;
78 fSigmaFunUp[icut]=0;
79 fFunSigma[icut]=0x0;
8c2440d0 80 fVarCuts[icut]=0x0;
8df8e382 81 }
82}
83
84//______________________________________________
85AliDielectronPID::AliDielectronPID(const char* name, const char* title) :
86 AliAnalysisCuts(name, title),
87 fNcuts(0),
8d42b5b9 88 fPIDResponse(0x0)
8df8e382 89{
90 //
91 // Named Constructor
92 //
93 for (Int_t icut=0; icut<kNmaxPID; ++icut){
94 fDetType[icut]=kTPC;
95 fPartType[icut]=AliPID::kPion;
96 fNsigmaLow[icut]=0;
97 fNsigmaUp[icut]=0;
5720c765 98 fmin[icut]=0;
99 fmax[icut]=0;
8df8e382 100 fExclude[icut]=kFALSE;
101 fFunUpperCut[icut]=0x0;
102 fFunLowerCut[icut]=0x0;
61d106d3 103 fRequirePIDbit[icut]=0;
5720c765 104 fActiveCuts[icut]=0;
88204efa 105 fSigmaFunLow[icut]=0;
106 fSigmaFunUp[icut]=0;
107 fFunSigma[icut]=0x0;
8c2440d0 108 fVarCuts[icut]=0x0;
8df8e382 109 }
110}
111
112//______________________________________________
113AliDielectronPID::~AliDielectronPID()
114{
115 //
116 // Default Destructor
117 //
118}
119
120//______________________________________________
121void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, Double_t nSigmaUp/*=-99999.*/,
5720c765 122 Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
123 UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
8df8e382 124{
125 //
126 // Add a pid nsigma cut
5720c765 127 // use response of detector 'det' in the range ['min'] to ['max'] for var
128 // use a sigma band between 'nSigmaLow' and 'nSigmaUp'
8df8e382 129 // if nSigmaUp==-99999. then nSigmaLow will be uesd as a symmetric band +- nSigmaLow
130 // specify whether to 'exclude' the given band
131 //
132
45b2b1b8 133 if (fNcuts>=kNmaxPID){
8df8e382 134 AliError(Form("only %d pid cut ranges allowed",kNmaxPID));
45b2b1b8 135 return;
8df8e382 136 }
137 if (TMath::Abs(nSigmaUp+99999.)<1e-20){
138 nSigmaUp=TMath::Abs(nSigmaLow);
139 nSigmaLow=-1.*nSigmaUp;
140 }
141 fDetType[fNcuts]=det;
142 fPartType[fNcuts]=type;
143 fNsigmaLow[fNcuts]=nSigmaLow;
144 fNsigmaUp[fNcuts]=nSigmaUp;
5720c765 145 fmin[fNcuts]=min;
146 fmax[fNcuts]=max;
8df8e382 147 fExclude[fNcuts]=exclude;
61d106d3 148 fRequirePIDbit[fNcuts]=pidBitType;
5720c765 149 fActiveCuts[fNcuts]=(var==-1 ? AliDielectronVarManager::kP : var);
150
fd6ebd85 151 AliDebug(1,Form("Add PID cut %d: sigma [% .1f,% .1f] \t cut [% .1f,% .f] \t var %d->%s \n",
152 fNcuts,nSigmaLow,nSigmaUp,min,max,fActiveCuts[fNcuts],AliDielectronVarManager::GetValueName(fActiveCuts[fNcuts])));
8df8e382 153
5720c765 154 ++fNcuts;
155
8df8e382 156}
157
158//______________________________________________
159void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, TF1 * const funUp,
5720c765 160 Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
161 UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
8df8e382 162{
163 //
164 // cut using a TF1 as upper cut
165 //
166 if (funUp==0x0){
167 AliError("A valid function is required for the upper cut. Not adding the cut!");
168 return;
169 }
170 fFunUpperCut[fNcuts]=funUp;
5720c765 171 AddCut(det,type,nSigmaLow,0.,min,max,exclude,pidBitType,var);
8df8e382 172}
173
174//______________________________________________
175void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, TF1 * const funLow, Double_t nSigmaUp,
5720c765 176 Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
177 UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
8df8e382 178{
179 //
180 // cut using a TF1 as lower cut
181 //
182 if (funLow==0x0){
183 AliError("A valid function is required for the lower cut. Not adding the cut!");
184 return;
185 }
186 fFunLowerCut[fNcuts]=funLow;
5720c765 187 AddCut(det,type,0.,nSigmaUp,min,max,exclude,pidBitType,var);
8df8e382 188}
189
190//______________________________________________
191void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, TF1 * const funLow, TF1 * const funUp,
5720c765 192 Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
193 UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
8df8e382 194{
195 //
196 // cut using a TF1 as lower and upper cut
197 //
198 if ( (funUp==0x0) || (funLow==0x0) ){
199 AliError("A valid function is required for upper and lower cut. Not adding the cut!");
200 return;
201 }
202 fFunUpperCut[fNcuts]=funUp;
203 fFunLowerCut[fNcuts]=funLow;
5720c765 204 AddCut(det,type,0.,0.,min,max,exclude,pidBitType,var);
8df8e382 205}
206
88204efa 207//______________________________________________
208void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, Double_t nSigmaUp,
209 Double_t min, Double_t max, Bool_t exclude,
210 UInt_t pidBitType, TF1 * const funSigma)
211{
212 //
213 // cut using a TF1 as lower cut
214 //
215 if (funSigma==0x0){
216 AliError("A valid function is required for the sigma cut. Not adding the cut!");
217 return;
218 }
219 fFunSigma[fNcuts]=funSigma;
220 fSigmaFunLow[fNcuts]=min;
221 fSigmaFunUp[fNcuts]=max;
222
223 AddCut(det,type,nSigmaLow,nSigmaUp,0,0,exclude,pidBitType,-1);
224}
225
8c2440d0 226//______________________________________________
227void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, Double_t nSigmaUp,
228 AliDielectronVarCuts *var, Bool_t exclude/*=kFALSE*/,
229 UInt_t pidBitType/*=AliDielectronPID::kRequire*/)
230{
231 //
232 // Add a pid nsigma cut
233 // use response of detector 'det' in the ranges for variables defined in var
234 // use a sigma band between 'nSigmaLow' and 'nSigmaUp'
235 // if nSigmaUp==-99999. then nSigmaLow will be uesd as a symmetric band +- nSigmaLow
236 // specify whether to 'exclude' the given band
237 //
238 if(!var) return;
239 if (fNcuts>=kNmaxPID){
240 AliError(Form("only %d pid cut ranges allowed",kNmaxPID));
241 return;
242 }
243 if (TMath::Abs(nSigmaUp+99999.)<1e-20){
244 nSigmaUp=TMath::Abs(nSigmaLow);
245 nSigmaLow=-1.*nSigmaUp;
246 }
247 fDetType[fNcuts]=det;
248 fPartType[fNcuts]=type;
249 fNsigmaLow[fNcuts]=nSigmaLow;
250 fNsigmaUp[fNcuts]=nSigmaUp;
251 fExclude[fNcuts]=exclude;
252 fRequirePIDbit[fNcuts]=pidBitType;
253 fVarCuts[fNcuts]=var;
254
255 AliDebug(1,Form("Add PID cut %d: sigma [% .1f,% .1f] \n",
256 fNcuts,nSigmaLow,nSigmaUp));
257
258 ++fNcuts;
259
260}
261
8df8e382 262//______________________________________________
263Bool_t AliDielectronPID::IsSelected(TObject* track)
264{
265 //
266 // perform PID cuts
267 //
268
269 //loop over all cuts
164bfb53 270 AliVTrack *part=static_cast<AliVTrack*>(track);
5720c765 271 AliESDtrack *esdTrack=0x0;
0c09cae4 272 AliAODTrack *aodTrack=0x0;
5720c765 273 Double_t origdEdx=-1;
8df8e382 274
5720c765 275 // apply ETa correction, remove once this is in the tender
0c09cae4 276 if( (part->IsA() == AliESDtrack::Class()) ){
5720c765 277 esdTrack=static_cast<AliESDtrack*>(part);
278 origdEdx=esdTrack->GetTPCsignal();
d327d9cd 279 esdTrack->SetTPCsignal(origdEdx/GetEtaCorr(esdTrack)/fgCorrdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
0c09cae4 280 } else if ( (part->IsA() == AliAODTrack::Class()) ){
281 aodTrack=static_cast<AliAODTrack*>(track);
282 AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
423cc7ef 283 if (pid){
284 origdEdx=pid->GetTPCsignal();
285 pid->SetTPCsignal(origdEdx/GetEtaCorr(aodTrack)/fgCorrdEdx);
286 }
5720c765 287 }
5720c765 288
289 //Fill values
290 Double_t values[AliDielectronVarManager::kNMaxValues];
291 AliDielectronVarManager::Fill(track,values);
8df8e382 292
5720c765 293 Bool_t selected=kFALSE;
294 fPIDResponse=AliDielectronVarManager::GetPIDResponse();
295 for (UChar_t icut=0; icut<fNcuts; ++icut){
296 Double_t min=fmin[icut];
297 Double_t max=fmax[icut];
298 Double_t val=values[fActiveCuts[icut]];
8d42b5b9 299
8c2440d0 300 // test var range. In case min==max do not cut
301 if ( fVarCuts[icut] ) {
302 if ( !fVarCuts[icut]->IsSelected(part) ) continue;
303 }
304 else if ( ( (TMath::Abs(min-max)>1e-20) && (val<min || val>=max) ) ) {
305 continue;
306 }
88204efa 307
308 // check if fFunSigma is set, then check if 'part' is in sigma range of the function
309 if(fFunSigma[icut]){
310 val= fPIDResponse->NumberOfSigmasTPC(part, fPartType[icut]);
311 if (fPartType[icut]==AliPID::kElectron){
312 val-=fgCorr;
313 }
314 min= fFunSigma[icut]->Eval(part->GetTPCmomentum())+fSigmaFunLow[icut];
315 max= fFunSigma[icut]->Eval(part->GetTPCmomentum())+fSigmaFunUp[icut];
316 if(val<min || val>=max) continue;
317 }
318
8df8e382 319 switch (fDetType[icut]){
320 case kITS:
321 selected = IsSelectedITS(part,icut);
322 break;
323 case kTPC:
324 selected = IsSelectedTPC(part,icut);
325 break;
326 case kTRD:
327 selected = IsSelectedTRD(part,icut);
328 break;
5720c765 329 case kTRDeleEff:
330 selected = IsSelectedTRDeleEff(part,icut);
331 break;
6d5dea7c 332 case kTRDeleEff2D:
333 selected = IsSelectedTRDeleEff(part,icut,AliTRDPIDResponse::kLQ2D);
334 break;
8df8e382 335 case kTOF:
336 selected = IsSelectedTOF(part,icut);
337 break;
5720c765 338 case kEMCAL:
339 selected = IsSelectedEMCAL(part,icut);
340 break;
341 }
342 if (!selected) {
343 if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
0c09cae4 344 else if (aodTrack){
345 AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
423cc7ef 346 if (pid) pid->SetTPCsignal(origdEdx);
0c09cae4 347 }
5720c765 348
349 return kFALSE;
8df8e382 350 }
8df8e382 351 }
352
5720c765 353 if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
0c09cae4 354 else if (aodTrack){
355 AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
423cc7ef 356 if (pid) pid->SetTPCsignal(origdEdx);
0c09cae4 357 }
8df8e382 358 return selected;
359}
360
361//______________________________________________
ffbede40 362Bool_t AliDielectronPID::IsSelectedITS(AliVTrack * const part, Int_t icut)
8df8e382 363{
364 //
365 // ITS part of the PID check
366 // Don't accept the track if there was no pid bit set
367 //
b2ad74d0 368 AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kITS,part);
369 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
370 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
ffbede40 371
372 Double_t mom=part->P();
164bfb53 373
5720c765 374 Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasITS(part, fPartType[icut]);
ffbede40 375
376 // test if we are supposed to use a function for the cut
377 if (fFunUpperCut[icut]) fNsigmaUp[icut] =fFunUpperCut[icut]->Eval(mom);
378 if (fFunLowerCut[icut]) fNsigmaLow[icut]=fFunLowerCut[icut]->Eval(mom);
379
8df8e382 380 Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
381 return selected;
382}
383
384//______________________________________________
ffbede40 385Bool_t AliDielectronPID::IsSelectedTPC(AliVTrack * const part, Int_t icut)
8df8e382 386{
387 //
388 // TPC part of the PID check
389 // Don't accept the track if there was no pid bit set
390 //
b2ad74d0 391 AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kTPC,part);
392 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
393 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
48609e3d 394
5720c765 395 Double_t mom=part->GetTPCmomentum();
8d42b5b9 396
5720c765 397 Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasTPC(part, fPartType[icut]);
398
2a14a7b1 399 if (fPartType[icut]==AliPID::kElectron){
400 numberOfSigmas-=fgCorr;
61749cc7 401 numberOfSigmas-=GetCntrdCorr(part);
402 numberOfSigmas/=GetWdthCorr(part);
8df8e382 403 }
8d42b5b9 404
ffbede40 405 // test if we are supposed to use a function for the cut
406 if (fFunUpperCut[icut]) fNsigmaUp[icut] =fFunUpperCut[icut]->Eval(mom);
407 if (fFunLowerCut[icut]) fNsigmaLow[icut]=fFunLowerCut[icut]->Eval(mom);
8d42b5b9 408
409 Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
8df8e382 410 return selected;
411}
412
413//______________________________________________
5720c765 414Bool_t AliDielectronPID::IsSelectedTRD(AliVTrack * const part, Int_t icut)
8df8e382 415{
416 //
417 // TRD part of the pid check
5720c765 418 // the TRD checks on the probabilities.
419 //
420
b2ad74d0 421 AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kTRD,part);
422 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
423 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
424
5720c765 425 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable && (part->GetTRDntrackletsPID()<4)) return kTRUE;
426
427 Double_t p[AliPID::kSPECIES]={0.};
428 fPIDResponse->ComputeTRDProbability(part,AliPID::kSPECIES,p);
429 Float_t particleProb=p[fPartType[icut]];
430
431 Bool_t selected=((particleProb>=fNsigmaLow[icut])&&(particleProb<=fNsigmaUp[icut]))^fExclude[icut];
432 return selected;
433}
434
435//______________________________________________
6d5dea7c 436Bool_t AliDielectronPID::IsSelectedTRDeleEff(AliVTrack * const part, Int_t icut, AliTRDPIDResponse::ETRDPIDMethod PIDmethod)
5720c765 437{
8df8e382 438 //
5720c765 439 // TRD part of the pid check using electron efficiency requirement
440 // in this case the upper limit as well as the particle specie is ignored
441 // and the lower limit regarded as the requested electron efficiency
442 //
443
b2ad74d0 444 AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kTRD,part);
445 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
446 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
5720c765 447
6d5dea7c 448 Double_t centrality = -1.;
449 if(part->IsA() == AliESDtrack::Class())
450 centrality=(const_cast<AliESDEvent*>( (static_cast<const AliESDtrack*>(part))->GetESDEvent()) )->GetCentrality()->GetCentralityPercentile("V0M");
451 if(part->IsA() == AliAODTrack::Class())
452 centrality=(const_cast<AliAODEvent*>( (static_cast<const AliAODTrack*>(part))->GetAODEvent()) )->GetCentrality()->GetCentralityPercentile("V0M");
453
454 Bool_t selected=fPIDResponse->IdentifiedAsElectronTRD(part,fNsigmaLow[icut], centrality, PIDmethod)^fExclude[icut];
5720c765 455 return selected;
8df8e382 456}
457
458//______________________________________________
ffbede40 459Bool_t AliDielectronPID::IsSelectedTOF(AliVTrack * const part, Int_t icut)
8df8e382 460{
461 //
462 // TOF part of the PID check
463 // Don't accept the track if there was no pid bit set
464 //
b2ad74d0 465 AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kTOF,part);
466 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
467 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
5720c765 468
469 Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasTOF(part, fPartType[icut]);
8df8e382 470
471 Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
472 return selected;
473}
474
5720c765 475//______________________________________________
476Bool_t AliDielectronPID::IsSelectedEMCAL(AliVTrack * const part, Int_t icut)
477{
478 //
479 // emcal pid selecttion
480 //
481
482 //TODO: correct way to check for emcal pid?
483 Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasEMCAL(part, fPartType[icut]);
484
485 Bool_t hasPID=numberOfSigmas>-998.;
486
487 if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!hasPID) return kFALSE;
488 if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!hasPID) return kTRUE;
489
490
491 Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
492 return selected;
493}
494
8df8e382 495//______________________________________________
496void AliDielectronPID::SetDefaults(Int_t def){
497 //
498 // initialise default pid strategies
499 //
500
501 if (def==0){
502 // 2sigma bands TPC:
503 // - include e
504 // - exclude mu,K,pi,p
505 // -complete p range
506 AddCut(kTPC,AliPID::kElectron,2);
507 AddCut(kTPC,AliPID::kMuon,-2.,2.,0.,0.,kTRUE);
508 AddCut(kTPC,AliPID::kPion,-2.,2.,0.,0.,kTRUE);
509 AddCut(kTPC,AliPID::kKaon,-2.,2.,0.,0.,kTRUE);
510 AddCut(kTPC,AliPID::kProton,-2.,2.,0.,0.,kTRUE);
511 } else if (def==1) {
512 // 2sigma bands TPC:
513 // - include e 0<p<inf
514 // - exclude mu,K,pi,p 0<p<2
8df8e382 515 AddCut(kTPC,AliPID::kElectron,2.);
516 AddCut(kTPC,AliPID::kMuon,-2.,2.,0.,2.,kTRUE);
517 AddCut(kTPC,AliPID::kPion,-2.,2.,0.,2.,kTRUE);
518 AddCut(kTPC,AliPID::kKaon,-2.,2.,0.,2.,kTRUE);
519 AddCut(kTPC,AliPID::kProton,-2.,2.,0.,2.,kTRUE);
520
521 } else if (def==2) {
522 // include 2sigma e TPC
523 // 3sigma bands TOF
524 // - exclude K,P
48609e3d 525 AddCut(kTPC,AliPID::kElectron,-3.,3.);
3505bfad 526 AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
527 AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
8df8e382 528
5720c765 529 } else if (def==3 || def==4) { // def3 and def4 are the same??
8df8e382 530 // include 2sigma e TPC
531 // 3sigma bands TOF
532 // - exclude K 0<p<1
533 // - exclude P 0<p<2
534 AddCut(kTPC,AliPID::kElectron,2);
535 AddCut(kTOF,AliPID::kKaon,-3.,3.,0.,1.,kTRUE);
536 AddCut(kTOF,AliPID::kProton,-6.,6.,0.,1.,kTRUE);
537 AddCut(kTOF,AliPID::kProton,-3.,3.,1.,2.,kTRUE);
538
8df8e382 539 } else if (def==5) {
540 AddCut(kTPC,AliPID::kElectron,-0.5,3);
541 AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
542 } else if (def==6) {
543 // lower cut TPC: parametrisation by HFE
544 // upper cut TPC: 3 sigma
545 // TOF ele band 3sigma 0<p<1.5GeV
546 TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)", 0, 100);
547 lowerCut->SetParameters(-2.7,-0.4357);
548 AddCut(kTPC,AliPID::kElectron,lowerCut,3.);
549 AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
550 } else if (def==7) {
61d106d3 551 // wide TPC cut
8df8e382 552 // TOF ele band 3sigma 0<p<1.5GeV
553 AddCut(kTPC,AliPID::kElectron,10.);
554 AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
61d106d3 555 } else if (def==8) {
556 // TOF 5 sigma inclusion if TOFpid available
557 // this should reduce K,p,Pi to a large extent
558 AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
559 } else if (def==9) {
560 // lower cut TPC: parametrisation by HFE
561 // upper cut TPC: 3 sigma
562 // TOF 5 sigma inclusion if TOFpid available
563 // this should reduce K,p,Pi to a large extent
564 TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)", 0, 100);
164bfb53 565 lowerCut->SetParameters(-2.65,-0.6757);
566 AddCut(kTPC,AliPID::kElectron,lowerCut,4.);
61d106d3 567 AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
ba15fdfb 568
61d106d3 569 } else if (def==10) {
570 AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
571 AddCut(kTPC,AliPID::kElectron,3.);
572 AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
573 AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
574
ba15fdfb 575 } else if (def==11) {
576 // lower cut TPC: parametrisation by HFE
577 // only use from period d on !!
578 // upper cut TPC: 3 sigma
579 // TOF ele band 3sigma 0<p<2.0GeV
580 TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)+[2]", 0, 100);
581 lowerCut->SetParameters(-3.718,-0.4,0.27);
582 AddCut(kTPC,AliPID::kElectron,lowerCut,3.);
583 AddCut(kTOF,AliPID::kElectron,-3,3,0,2.);
584 } else if (def==12) {
585 // lower cut TPC: parametrisation by HFE
586 // only use from period d on !!
587 // upper cut TPC: 3 sigma
588 // TOF 5 sigma inclusion if TOFpid available
589 // this should reduce K,p,Pi to a large extent
590 TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)+[2]", 0, 100);
591 lowerCut->SetParameters(-3.718,-0.4,0.27);
592 AddCut(kTPC,AliPID::kElectron,lowerCut,4.);
593 AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
8df8e382 594 }
882407d7 595 else if (def==13) {
596 // TPC electron inclusion
597 // TOF electron inclusion if available
8d42b5b9 598 AddCut(kTOF,AliPID::kElectron,-3.,3.,0,200,kFALSE,AliDielectronPID::kIfAvailable);
599 AddCut(kTPC,AliPID::kElectron,10.);
882407d7 600 }
069b0c7a 601 else if (def==14) {
602 // TRD 1D 90% elec eff, 4-6 tracklets
603 // TPC electron inclusion
604 // TOF electron inclusion if available
605 AddCut(AliDielectronPID::kTRDeleEff,AliPID::kElectron,.9,1.,3.5,6.,kFALSE,
606 AliDielectronPID::kIfAvailable,AliDielectronVarManager::kTRDpidQuality);
8d42b5b9 607 AddCut(kTOF,AliPID::kElectron,-3.,3.,0,200,kFALSE,AliDielectronPID::kIfAvailable);
608 AddCut(kTPC,AliPID::kElectron,10.);
069b0c7a 609 }
610 else if (def==15) {
611 // TRD 1D 90% elec eff, 4-6 tracklets, chi2 < 2
612 // TPC electron inclusion
613 // TOF electron inclusion if available
614 AddCut(AliDielectronPID::kTRDeleEff,AliPID::kElectron,.9,1.,3.5,6.,kFALSE,
615 AliDielectronPID::kIfAvailable,AliDielectronVarManager::kTRDpidQuality);
616 AddCut(AliDielectronPID::kTRDeleEff,AliPID::kElectron,.9,1.,0.,2.,kFALSE,
617 AliDielectronPID::kIfAvailable,AliDielectronVarManager::kTRDchi2);
8d42b5b9 618 AddCut(kTOF,AliPID::kElectron,-3.,3.,0,200,kFALSE,AliDielectronPID::kIfAvailable);
619 AddCut(kTPC,AliPID::kElectron,10.);
620 }
621 else if (def==16) {
622 // TPC electron inclusion
623 // TOF electron inclusion if available
624 AddCut(kTOF,AliPID::kElectron,-3.,3.,0,200,kFALSE,AliDielectronPID::kIfAvailable);
625 AddCut(kTPC,AliPID::kElectron,-3.5,+3.5);
6675aa47 626 }
ba15fdfb 627
8df8e382 628}
629
48609e3d 630//______________________________________________
631void AliDielectronPID::SetCorrVal(Double_t run)
632{
633 //
634 // set correction value for run
635 //
d327d9cd 636 fgCorr=0.;
637 fgCorrdEdx=1.;
638
639 if (fgFitCorr){
640 fgCorr=fgFitCorr->Eval(run);
641 if (run<fgFitCorr->GetX()[0]) fgCorr=fgFitCorr->GetY()[0];
642 if (run>fgFitCorr->GetX()[fgFitCorr->GetN()-1]) fgCorr=fgFitCorr->GetY()[fgFitCorr->GetN()-1];
643 }
644
645 if (fgdEdxRunCorr){
646 fgCorrdEdx=fgdEdxRunCorr->Eval(run);
647 if (run<fgdEdxRunCorr->GetX()[0]) fgCorrdEdx=fgdEdxRunCorr->GetY()[0];
648 if (run>fgdEdxRunCorr->GetX()[fgFitCorr->GetN()-1]) fgCorrdEdx=fgdEdxRunCorr->GetY()[fgdEdxRunCorr->GetN()-1];
649 }
48609e3d 650}
651
5720c765 652//______________________________________________
0c09cae4 653Double_t AliDielectronPID::GetEtaCorr(const AliVTrack *track)
5720c765 654{
655 //
656 // return eta correction
657 //
658 if (!fgFunEtaCorr) return 1;
659 return fgFunEtaCorr->Eval(track->Eta());
660}
61749cc7 661
61749cc7 662//______________________________________________
663Double_t AliDielectronPID::GetPIDCorr(const AliVTrack *track, TF1 *fun)
664{
665 //
666 // return correction value
667 //
668
669 //Fill only event and vparticle values (otherwise we end up in a circle)
670 Double_t values[AliDielectronVarManager::kNMaxValues];
671 AliDielectronVarManager::FillVarVParticle(track,values);
672
673 Int_t dim=fun->GetNdim();
674 Double_t var[3] = {0.,0.,0.};
675 if(dim>0) var[0] = values[fun->GetHistogram()->GetXaxis()->GetUniqueID()];
676 if(dim>1) var[1] = values[fun->GetHistogram()->GetYaxis()->GetUniqueID()];
677 if(dim>2) var[2] = values[fun->GetHistogram()->GetZaxis()->GetUniqueID()];
678 Double_t corr = fun->Eval(var[0],var[1],var[2]);
30f9a393 679 // printf("%d-dim CORR value: %f (track %p) \n",dim,corr,track);
61749cc7 680 return corr;
681}