PWGDQ/dielectron/AliDielectronPID.cxx

   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 /*
  21 Detailed description
  22
  23
  24 */
  25 //                                                                       //
  26 ///////////////////////////////////////////////////////////////////////////
  27
  28 #include <TMath.h>
  29 #include <TF1.h>
  30 #include <TGraph.h>
  31
  32 #include <AliVTrack.h>
  33 #include <AliVCluster.h>
  34 #include <AliLog.h>
  35 #include <AliExternalTrackParam.h>
  36 #include <AliPIDResponse.h>
  37 #include <AliTRDPIDResponse.h>
  38 #include <AliESDtrack.h> //!!!!! Remove once Eta correction is treated in the tender
  39 #include <AliAODTrack.h>
  40 #include <AliAODPid.h>
  41
  42 #include "AliDielectronVarManager.h"
  43
  44 #include "AliDielectronPID.h"
  45
  46 ClassImp(AliDielectronPID)
  47
  48 TGraph *AliDielectronPID::fgFitCorr=0x0;
  49 Double_t AliDielectronPID::fgCorr=0.0;
  50 Double_t AliDielectronPID::fgCorrdEdx=1.0;
  51 TF1 *AliDielectronPID::fgFunEtaCorr=0x0;
  52 TGraph *AliDielectronPID::fgdEdxRunCorr=0x0;
  53
  54 AliDielectronPID::AliDielectronPID() :
  55   AliAnalysisCuts(),
  56   fNcuts(0),
  57   fPIDResponse(0x0)
  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;
  67     fmin[icut]=0;
  68     fmax[icut]=0;
  69     fExclude[icut]=kFALSE;
  70     fFunUpperCut[icut]=0x0;
  71     fFunLowerCut[icut]=0x0;
  72     fRequirePIDbit[icut]=0;
  73     fActiveCuts[icut]=-1;
  74     fSigmaFunLow[icut]=0;
  75     fSigmaFunUp[icut]=0;
  76     fFunSigma[icut]=0x0;
  77   }
  78 }
  79
  80 //______________________________________________
  81 AliDielectronPID::AliDielectronPID(const char* name, const char* title) :
  82   AliAnalysisCuts(name, title),
  83   fNcuts(0),
  84   fPIDResponse(0x0)
  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;
  94     fmin[icut]=0;
  95     fmax[icut]=0;
  96     fExclude[icut]=kFALSE;
  97     fFunUpperCut[icut]=0x0;
  98     fFunLowerCut[icut]=0x0;
  99     fRequirePIDbit[icut]=0;
 100     fActiveCuts[icut]=0;
 101     fSigmaFunLow[icut]=0;
 102     fSigmaFunUp[icut]=0;
 103     fFunSigma[icut]=0x0;
 104   }
 105 }
 106
 107 //______________________________________________
 108 AliDielectronPID::~AliDielectronPID()
 109 {
 110   //
 111   // Default Destructor
 112   //
 113 }
 114
 115 //______________________________________________
 116 void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, Double_t nSigmaUp/*=-99999.*/,
 117                               Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
 118                               UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
 119 {
 120   //
 121   // Add a pid nsigma cut
 122   // use response of detector 'det' in the range ['min'] to ['max'] for var
 123   // use a sigma band between 'nSigmaLow' and 'nSigmaUp'
 124   // if nSigmaUp==-99999. then nSigmaLow will be uesd as a symmetric band +- nSigmaLow
 125   // specify whether to 'exclude' the given band
 126   //
 127
 128   if (fNcuts>=kNmaxPID){
 129     AliError(Form("only %d pid cut ranges allowed",kNmaxPID));
 130     return;
 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;
 140   fmin[fNcuts]=min;
 141   fmax[fNcuts]=max;
 142   fExclude[fNcuts]=exclude;
 143   fRequirePIDbit[fNcuts]=pidBitType;
 144   fActiveCuts[fNcuts]=(var==-1 ? AliDielectronVarManager::kP : var);
 145
 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])));
 148
 149   ++fNcuts;
 150
 151 }
 152
 153 //______________________________________________
 154 void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, Double_t nSigmaLow, TF1 * const funUp,
 155                               Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
 156                               UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
 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;
 166   AddCut(det,type,nSigmaLow,0.,min,max,exclude,pidBitType,var);
 167 }
 168
 169 //______________________________________________
 170 void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, TF1 * const funLow, Double_t nSigmaUp,
 171                               Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
 172                               UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
 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;
 182   AddCut(det,type,0.,nSigmaUp,min,max,exclude,pidBitType,var);
 183 }
 184
 185 //______________________________________________
 186 void AliDielectronPID::AddCut(DetType det, AliPID::EParticleType type, TF1 * const funLow, TF1 * const funUp,
 187                               Double_t min/*=0*/, Double_t max/*=0*/, Bool_t exclude/*=kFALSE*/,
 188                               UInt_t pidBitType/*=AliDielectronPID::kRequire*/, Int_t var/*=-1*/)
 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;
 199   AddCut(det,type,0.,0.,min,max,exclude,pidBitType,var);
 200 }
 201
 202 //______________________________________________
 203 void 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
 221 //______________________________________________
 222 Bool_t AliDielectronPID::IsSelected(TObject* track)
 223 {
 224   //
 225   // perform PID cuts
 226   //
 227
 228   //loop over all cuts
 229   AliVTrack *part=static_cast<AliVTrack*>(track);
 230   AliESDtrack *esdTrack=0x0;
 231   AliAODTrack *aodTrack=0x0;
 232   Double_t origdEdx=-1;
 233
 234   // apply ETa correction, remove once this is in the tender
 235   if( (part->IsA() == AliESDtrack::Class()) ){
 236     esdTrack=static_cast<AliESDtrack*>(part);
 237     origdEdx=esdTrack->GetTPCsignal();
 238     esdTrack->SetTPCsignal(origdEdx/GetEtaCorr(esdTrack)/fgCorrdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
 239   } else if ( (part->IsA() == AliAODTrack::Class()) ){
 240     aodTrack=static_cast<AliAODTrack*>(track);
 241     AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
 242     if (pid){
 243       origdEdx=pid->GetTPCsignal();
 244       pid->SetTPCsignal(origdEdx/GetEtaCorr(aodTrack)/fgCorrdEdx);
 245     }
 246   }
 247
 248   //Fill values
 249   Double_t values[AliDielectronVarManager::kNMaxValues];
 250   AliDielectronVarManager::Fill(track,values);
 251
 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;
 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
 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;
 284     case kTRDeleEff:
 285       selected = IsSelectedTRDeleEff(part,icut);
 286       break;
 287     case kTRDeleEff2D:
 288       selected = IsSelectedTRDeleEff(part,icut,AliTRDPIDResponse::kLQ2D);
 289       break;
 290     case kTOF:
 291       selected = IsSelectedTOF(part,icut);
 292       break;
 293     case kEMCAL:
 294       selected = IsSelectedEMCAL(part,icut);
 295       break;
 296     }
 297     if (!selected) {
 298       if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
 299       else if (aodTrack){
 300         AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
 301         if (pid) pid->SetTPCsignal(origdEdx);
 302       }
 303
 304       return kFALSE;
 305     }
 306   }
 307
 308   if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
 309   else if (aodTrack){
 310     AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
 311     if (pid) pid->SetTPCsignal(origdEdx);
 312   }
 313   return selected;
 314 }
 315
 316 //______________________________________________
 317 Bool_t AliDielectronPID::IsSelectedITS(AliVTrack * const part, Int_t icut)
 318 {
 319   //
 320   // ITS part of the PID check
 321   // Don't accept the track if there was no pid bit set
 322   //
 323   AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kITS,part);
 324   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
 325   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
 326
 327   Double_t mom=part->P();
 328
 329   Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasITS(part, fPartType[icut]);
 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
 335   Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
 336   return selected;
 337 }
 338
 339 //______________________________________________
 340 Bool_t AliDielectronPID::IsSelectedTPC(AliVTrack * const part, Int_t icut)
 341 {
 342   //
 343   // TPC part of the PID check
 344   // Don't accept the track if there was no pid bit set
 345   //
 346   AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kTPC,part);
 347   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
 348   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
 349
 350   Double_t mom=part->GetTPCmomentum();
 351
 352   Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasTPC(part, fPartType[icut]);
 353
 354   if (fPartType[icut]==AliPID::kElectron){
 355     numberOfSigmas-=fgCorr;
 356   }
 357
 358   // test if we are supposed to use a function for the cut
 359   if (fFunUpperCut[icut]) fNsigmaUp[icut] =fFunUpperCut[icut]->Eval(mom);
 360   if (fFunLowerCut[icut]) fNsigmaLow[icut]=fFunLowerCut[icut]->Eval(mom);
 361
 362   Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
 363   return selected;
 364 }
 365
 366 //______________________________________________
 367 Bool_t AliDielectronPID::IsSelectedTRD(AliVTrack * const part, Int_t icut)
 368 {
 369   //
 370   // TRD part of the pid check
 371   // the TRD checks on the probabilities.
 372   //
 373
 374   AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kTRD,part);
 375   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
 376   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
 377
 378   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable && (part->GetTRDntrackletsPID()<4)) return kTRUE;
 379
 380   Double_t p[AliPID::kSPECIES]={0.};
 381   fPIDResponse->ComputeTRDProbability(part,AliPID::kSPECIES,p);
 382   Float_t particleProb=p[fPartType[icut]];
 383
 384   Bool_t selected=((particleProb>=fNsigmaLow[icut])&&(particleProb<=fNsigmaUp[icut]))^fExclude[icut];
 385   return selected;
 386 }
 387
 388 //______________________________________________
 389 Bool_t AliDielectronPID::IsSelectedTRDeleEff(AliVTrack * const part, Int_t icut, AliTRDPIDResponse::ETRDPIDMethod PIDmethod)
 390 {
 391   //
 392   // TRD part of the pid check using electron efficiency requirement
 393   // in this case the upper limit as well as the particle specie is ignored
 394   //   and the lower limit regarded as the requested electron efficiency
 395   //
 396
 397   AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kTRD,part);
 398   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
 399   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
 400
 401   Double_t centrality = -1.;
 402   if(part->IsA() == AliESDtrack::Class())
 403     centrality=(const_cast<AliESDEvent*>( (static_cast<const AliESDtrack*>(part))->GetESDEvent()) )->GetCentrality()->GetCentralityPercentile("V0M");
 404   if(part->IsA() == AliAODTrack::Class())
 405     centrality=(const_cast<AliAODEvent*>( (static_cast<const AliAODTrack*>(part))->GetAODEvent()) )->GetCentrality()->GetCentralityPercentile("V0M");
 406
 407   Bool_t selected=fPIDResponse->IdentifiedAsElectronTRD(part,fNsigmaLow[icut], centrality, PIDmethod)^fExclude[icut];
 408   return selected;
 409 }
 410
 411 //______________________________________________
 412 Bool_t AliDielectronPID::IsSelectedTOF(AliVTrack * const part, Int_t icut)
 413 {
 414   //
 415   // TOF part of the PID check
 416   // Don't accept the track if there was no pid bit set
 417   //
 418   AliPIDResponse::EDetPidStatus pidStatus = fPIDResponse->CheckPIDStatus(AliPIDResponse::kTOF,part);
 419   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kFALSE;
 420   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&(pidStatus!=AliPIDResponse::kDetPidOk)) return kTRUE;
 421
 422   Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasTOF(part, fPartType[icut]);
 423
 424   Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
 425   return selected;
 426 }
 427
 428 //______________________________________________
 429 Bool_t AliDielectronPID::IsSelectedEMCAL(AliVTrack * const part, Int_t icut)
 430 {
 431   //
 432   // emcal pid selecttion
 433   //
 434
 435   //TODO: correct way to check for emcal pid?
 436   Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasEMCAL(part, fPartType[icut]);
 437
 438   Bool_t hasPID=numberOfSigmas>-998.;
 439
 440   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!hasPID) return kFALSE;
 441   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!hasPID) return kTRUE;
 442
 443
 444   Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
 445   return selected;
 446 }
 447
 448 //______________________________________________
 449 void AliDielectronPID::SetDefaults(Int_t def){
 450   //
 451   // initialise default pid strategies
 452   //
 453
 454   if (def==0){
 455     // 2sigma bands TPC:
 456     // - include e
 457     // - exclude mu,K,pi,p
 458     // -complete p range
 459     AddCut(kTPC,AliPID::kElectron,2);
 460     AddCut(kTPC,AliPID::kMuon,-2.,2.,0.,0.,kTRUE);
 461     AddCut(kTPC,AliPID::kPion,-2.,2.,0.,0.,kTRUE);
 462     AddCut(kTPC,AliPID::kKaon,-2.,2.,0.,0.,kTRUE);
 463     AddCut(kTPC,AliPID::kProton,-2.,2.,0.,0.,kTRUE);
 464   } else if (def==1) {
 465     // 2sigma bands TPC:
 466     // - include e 0<p<inf
 467     // - exclude mu,K,pi,p 0<p<2
 468     AddCut(kTPC,AliPID::kElectron,2.);
 469     AddCut(kTPC,AliPID::kMuon,-2.,2.,0.,2.,kTRUE);
 470     AddCut(kTPC,AliPID::kPion,-2.,2.,0.,2.,kTRUE);
 471     AddCut(kTPC,AliPID::kKaon,-2.,2.,0.,2.,kTRUE);
 472     AddCut(kTPC,AliPID::kProton,-2.,2.,0.,2.,kTRUE);
 473
 474   } else if (def==2) {
 475     // include 2sigma e TPC
 476     // 3sigma bands TOF
 477     // - exclude K,P
 478     AddCut(kTPC,AliPID::kElectron,-3.,3.);
 479     AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
 480     AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
 481
 482   } else if (def==3 || def==4) { // def3 and def4 are the same??
 483     // include 2sigma e TPC
 484     // 3sigma bands TOF
 485     // - exclude K 0<p<1
 486     // - exclude P 0<p<2
 487     AddCut(kTPC,AliPID::kElectron,2);
 488     AddCut(kTOF,AliPID::kKaon,-3.,3.,0.,1.,kTRUE);
 489     AddCut(kTOF,AliPID::kProton,-6.,6.,0.,1.,kTRUE);
 490     AddCut(kTOF,AliPID::kProton,-3.,3.,1.,2.,kTRUE);
 491
 492   } else if (def==5) {
 493     AddCut(kTPC,AliPID::kElectron,-0.5,3);
 494     AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
 495   } else if (def==6) {
 496     // lower cut TPC: parametrisation by HFE
 497     // upper cut TPC: 3 sigma
 498     // TOF ele band 3sigma 0<p<1.5GeV
 499     TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)", 0, 100);
 500     lowerCut->SetParameters(-2.7,-0.4357);
 501     AddCut(kTPC,AliPID::kElectron,lowerCut,3.);
 502     AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
 503   } else if (def==7) {
 504     // wide TPC cut
 505     // TOF ele band 3sigma 0<p<1.5GeV
 506     AddCut(kTPC,AliPID::kElectron,10.);
 507     AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
 508   } else if (def==8) {
 509     // TOF 5 sigma inclusion if TOFpid available
 510     // this should reduce K,p,Pi to a large extent
 511     AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 512   } else if (def==9) {
 513     // lower cut TPC: parametrisation by HFE
 514     // upper cut TPC: 3 sigma
 515     // TOF 5 sigma inclusion if TOFpid available
 516     // this should reduce K,p,Pi to a large extent
 517     TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)", 0, 100);
 518     lowerCut->SetParameters(-2.65,-0.6757);
 519     AddCut(kTPC,AliPID::kElectron,lowerCut,4.);
 520     AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 521
 522   } else if (def==10) {
 523     AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 524     AddCut(kTPC,AliPID::kElectron,3.);
 525     AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
 526     AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
 527
 528   } else if (def==11) {
 529     // lower cut TPC: parametrisation by HFE
 530     // only use from period d on !!
 531     // upper cut TPC: 3 sigma
 532     // TOF ele band 3sigma 0<p<2.0GeV
 533     TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)+[2]", 0, 100);
 534     lowerCut->SetParameters(-3.718,-0.4,0.27);
 535     AddCut(kTPC,AliPID::kElectron,lowerCut,3.);
 536     AddCut(kTOF,AliPID::kElectron,-3,3,0,2.);
 537   } else if (def==12) {
 538     // lower cut TPC: parametrisation by HFE
 539     // only use from period d on !!
 540     // upper cut TPC: 3 sigma
 541     // TOF 5 sigma inclusion if TOFpid available
 542     // this should reduce K,p,Pi to a large extent
 543     TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)+[2]", 0, 100);
 544     lowerCut->SetParameters(-3.718,-0.4,0.27);
 545     AddCut(kTPC,AliPID::kElectron,lowerCut,4.);
 546     AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 547   }
 548   else if (def==13) {
 549     // TPC electron inclusion
 550     // TOF electron inclusion if available
 551     AddCut(kTOF,AliPID::kElectron,-4.,4.,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 552     AddCut(kTPC,AliPID::kElectron,-3.5,3.5);
 553   }
 554   else if (def==14) {
 555     // TRD 1D 90% elec eff, 4-6 tracklets
 556     // TPC electron inclusion
 557     // TOF electron inclusion if available
 558     AddCut(AliDielectronPID::kTRDeleEff,AliPID::kElectron,.9,1.,3.5,6.,kFALSE,
 559            AliDielectronPID::kIfAvailable,AliDielectronVarManager::kTRDpidQuality);
 560     AddCut(kTOF,AliPID::kElectron,-4.,4.,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 561     AddCut(kTPC,AliPID::kElectron,-3.5,3.5);
 562   }
 563   else if (def==15) {
 564     // TRD 1D 90% elec eff, 4-6 tracklets, chi2 < 2
 565     // TPC electron inclusion
 566     // TOF electron inclusion if available
 567     AddCut(AliDielectronPID::kTRDeleEff,AliPID::kElectron,.9,1.,3.5,6.,kFALSE,
 568            AliDielectronPID::kIfAvailable,AliDielectronVarManager::kTRDpidQuality);
 569     AddCut(AliDielectronPID::kTRDeleEff,AliPID::kElectron,.9,1.,0.,2.,kFALSE,
 570            AliDielectronPID::kIfAvailable,AliDielectronVarManager::kTRDchi2);
 571     AddCut(kTOF,AliPID::kElectron,-4.,4.,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 572     AddCut(kTPC,AliPID::kElectron,-3.5,3.5);
 573   }
 574
 575 }
 576
 577 //______________________________________________
 578 void AliDielectronPID::SetCorrVal(Double_t run)
 579 {
 580   //
 581   // set correction value for run
 582   //
 583   fgCorr=0.;
 584   fgCorrdEdx=1.;
 585
 586   if (fgFitCorr){
 587     fgCorr=fgFitCorr->Eval(run);
 588     if (run<fgFitCorr->GetX()[0]) fgCorr=fgFitCorr->GetY()[0];
 589     if (run>fgFitCorr->GetX()[fgFitCorr->GetN()-1]) fgCorr=fgFitCorr->GetY()[fgFitCorr->GetN()-1];
 590   }
 591
 592   if (fgdEdxRunCorr){
 593     fgCorrdEdx=fgdEdxRunCorr->Eval(run);
 594     if (run<fgdEdxRunCorr->GetX()[0]) fgCorrdEdx=fgdEdxRunCorr->GetY()[0];
 595     if (run>fgdEdxRunCorr->GetX()[fgFitCorr->GetN()-1]) fgCorrdEdx=fgdEdxRunCorr->GetY()[fgdEdxRunCorr->GetN()-1];
 596   }
 597 }
 598
 599 //______________________________________________
 600 Double_t AliDielectronPID::GetEtaCorr(const AliVTrack *track)
 601 {
 602   //
 603   // return eta correction
 604   //
 605   if (!fgFunEtaCorr) return 1;
 606   return fgFunEtaCorr->Eval(track->Eta());
 607 }