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     origdEdx=pid->GetTPCsignal();
 243     pid->SetTPCsignal(origdEdx/GetEtaCorr(aodTrack)/fgCorrdEdx);
 244   }
 245
 246   //Fill values
 247   Double_t values[AliDielectronVarManager::kNMaxValues];
 248   AliDielectronVarManager::Fill(track,values);
 249
 250   Bool_t selected=kFALSE;
 251   fPIDResponse=AliDielectronVarManager::GetPIDResponse();
 252   for (UChar_t icut=0; icut<fNcuts; ++icut){
 253     Double_t min=fmin[icut];
 254     Double_t max=fmax[icut];
 255     Double_t val=values[fActiveCuts[icut]];
 256
 257     // test var range. In case min==max do not cut
 258     if ( (TMath::Abs(min-max)>1e-20) && (val<min || val>=max) ) continue;
 259
 260
 261     // check if fFunSigma is set, then check if 'part' is in sigma range of the function
 262     if(fFunSigma[icut]){
 263         val= fPIDResponse->NumberOfSigmasTPC(part, fPartType[icut]);
 264         if (fPartType[icut]==AliPID::kElectron){
 265             val-=fgCorr;
 266         }
 267         min= fFunSigma[icut]->Eval(part->GetTPCmomentum())+fSigmaFunLow[icut];
 268         max= fFunSigma[icut]->Eval(part->GetTPCmomentum())+fSigmaFunUp[icut];
 269         if(val<min || val>=max) continue;
 270     }
 271
 272     switch (fDetType[icut]){
 273     case kITS:
 274       selected = IsSelectedITS(part,icut);
 275       break;
 276     case kTPC:
 277       selected = IsSelectedTPC(part,icut);
 278       break;
 279     case kTRD:
 280       selected = IsSelectedTRD(part,icut);
 281       break;
 282     case kTRDeleEff:
 283       selected = IsSelectedTRDeleEff(part,icut);
 284       break;
 285     case kTRDeleEff2D:
 286       selected = IsSelectedTRDeleEff(part,icut,AliTRDPIDResponse::kLQ2D);
 287       break;
 288     case kTOF:
 289       selected = IsSelectedTOF(part,icut);
 290       break;
 291     case kEMCAL:
 292       selected = IsSelectedEMCAL(part,icut);
 293       break;
 294     }
 295     if (!selected) {
 296       if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
 297       else if (aodTrack){
 298         AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
 299         pid->SetTPCsignal(origdEdx);
 300       }
 301
 302       return kFALSE;
 303     }
 304   }
 305
 306   if (esdTrack) esdTrack->SetTPCsignal(origdEdx,esdTrack->GetTPCsignalSigma(),esdTrack->GetTPCsignalN());
 307   else if (aodTrack){
 308     AliAODPid *pid=const_cast<AliAODPid*>(aodTrack->GetDetPid());
 309     pid->SetTPCsignal(origdEdx);
 310   }
 311   return selected;
 312 }
 313
 314 //______________________________________________
 315 Bool_t AliDielectronPID::IsSelectedITS(AliVTrack * const part, Int_t icut)
 316 {
 317   //
 318   // ITS part of the PID check
 319   // Don't accept the track if there was no pid bit set
 320   //
 321
 322   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kITSpid)) return kFALSE;
 323   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kITSpid)) return kTRUE;
 324
 325   Double_t mom=part->P();
 326
 327   Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasITS(part, fPartType[icut]);
 328
 329   // test if we are supposed to use a function for the cut
 330   if (fFunUpperCut[icut]) fNsigmaUp[icut] =fFunUpperCut[icut]->Eval(mom);
 331   if (fFunLowerCut[icut]) fNsigmaLow[icut]=fFunLowerCut[icut]->Eval(mom);
 332
 333   Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
 334   return selected;
 335 }
 336
 337 //______________________________________________
 338 Bool_t AliDielectronPID::IsSelectedTPC(AliVTrack * const part, Int_t icut)
 339 {
 340   //
 341   // TPC part of the PID check
 342   // Don't accept the track if there was no pid bit set
 343   //
 344   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kTPCpid)) return kFALSE;
 345   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kTPCpid)) return kTRUE;
 346
 347   Double_t mom=part->GetTPCmomentum();
 348
 349   Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasTPC(part, fPartType[icut]);
 350
 351   if (fPartType[icut]==AliPID::kElectron){
 352     numberOfSigmas-=fgCorr;
 353   }
 354
 355   // test if we are supposed to use a function for the cut
 356   if (fFunUpperCut[icut]) fNsigmaUp[icut] =fFunUpperCut[icut]->Eval(mom);
 357   if (fFunLowerCut[icut]) fNsigmaLow[icut]=fFunLowerCut[icut]->Eval(mom);
 358
 359   Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
 360   return selected;
 361 }
 362
 363 //______________________________________________
 364 Bool_t AliDielectronPID::IsSelectedTRD(AliVTrack * const part, Int_t icut)
 365 {
 366   //
 367   // TRD part of the pid check
 368   // the TRD checks on the probabilities.
 369   //
 370
 371   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kTRDpid)) return kFALSE;
 372   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kTRDpid)) return kTRUE;
 373   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable && (part->GetTRDntrackletsPID()<4)) return kTRUE;
 374
 375   Double_t p[AliPID::kSPECIES]={0.};
 376   fPIDResponse->ComputeTRDProbability(part,AliPID::kSPECIES,p);
 377   Float_t particleProb=p[fPartType[icut]];
 378
 379   Bool_t selected=((particleProb>=fNsigmaLow[icut])&&(particleProb<=fNsigmaUp[icut]))^fExclude[icut];
 380   return selected;
 381 }
 382
 383 //______________________________________________
 384 Bool_t AliDielectronPID::IsSelectedTRDeleEff(AliVTrack * const part, Int_t icut, AliTRDPIDResponse::ETRDPIDMethod PIDmethod)
 385 {
 386   //
 387   // TRD part of the pid check using electron efficiency requirement
 388   // in this case the upper limit as well as the particle specie is ignored
 389   //   and the lower limit regarded as the requested electron efficiency
 390   //
 391
 392   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kTRDpid)) return kFALSE;
 393   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kTRDpid)) return kTRUE;
 394
 395   Double_t centrality = -1.;
 396   if(part->IsA() == AliESDtrack::Class())
 397     centrality=(const_cast<AliESDEvent*>( (static_cast<const AliESDtrack*>(part))->GetESDEvent()) )->GetCentrality()->GetCentralityPercentile("V0M");
 398   if(part->IsA() == AliAODTrack::Class())
 399     centrality=(const_cast<AliAODEvent*>( (static_cast<const AliAODTrack*>(part))->GetAODEvent()) )->GetCentrality()->GetCentralityPercentile("V0M");
 400
 401   Bool_t selected=fPIDResponse->IdentifiedAsElectronTRD(part,fNsigmaLow[icut], centrality, PIDmethod)^fExclude[icut];
 402   return selected;
 403 }
 404
 405 //______________________________________________
 406 Bool_t AliDielectronPID::IsSelectedTOF(AliVTrack * const part, Int_t icut)
 407 {
 408   //
 409   // TOF part of the PID check
 410   // Don't accept the track if there was no pid bit set
 411   //
 412
 413   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!(part->GetStatus()&AliVTrack::kTOFpid)) return kFALSE;
 414   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!(part->GetStatus()&AliVTrack::kTOFpid)) return kTRUE;
 415
 416   Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasTOF(part, fPartType[icut]);
 417
 418   Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
 419   return selected;
 420 }
 421
 422 //______________________________________________
 423 Bool_t AliDielectronPID::IsSelectedEMCAL(AliVTrack * const part, Int_t icut)
 424 {
 425   //
 426   // emcal pid selecttion
 427   //
 428
 429   //TODO: correct way to check for emcal pid?
 430   Float_t numberOfSigmas=fPIDResponse->NumberOfSigmasEMCAL(part, fPartType[icut]);
 431
 432   Bool_t hasPID=numberOfSigmas>-998.;
 433
 434   if (fRequirePIDbit[icut]==AliDielectronPID::kRequire&&!hasPID) return kFALSE;
 435   if (fRequirePIDbit[icut]==AliDielectronPID::kIfAvailable&&!hasPID) return kTRUE;
 436
 437
 438   Bool_t selected=((numberOfSigmas>=fNsigmaLow[icut])&&(numberOfSigmas<=fNsigmaUp[icut]))^fExclude[icut];
 439   return selected;
 440 }
 441
 442 //______________________________________________
 443 void AliDielectronPID::SetDefaults(Int_t def){
 444   //
 445   // initialise default pid strategies
 446   //
 447
 448   if (def==0){
 449     // 2sigma bands TPC:
 450     // - include e
 451     // - exclude mu,K,pi,p
 452     // -complete p range
 453     AddCut(kTPC,AliPID::kElectron,2);
 454     AddCut(kTPC,AliPID::kMuon,-2.,2.,0.,0.,kTRUE);
 455     AddCut(kTPC,AliPID::kPion,-2.,2.,0.,0.,kTRUE);
 456     AddCut(kTPC,AliPID::kKaon,-2.,2.,0.,0.,kTRUE);
 457     AddCut(kTPC,AliPID::kProton,-2.,2.,0.,0.,kTRUE);
 458   } else if (def==1) {
 459     // 2sigma bands TPC:
 460     // - include e 0<p<inf
 461     // - exclude mu,K,pi,p 0<p<2
 462     AddCut(kTPC,AliPID::kElectron,2.);
 463     AddCut(kTPC,AliPID::kMuon,-2.,2.,0.,2.,kTRUE);
 464     AddCut(kTPC,AliPID::kPion,-2.,2.,0.,2.,kTRUE);
 465     AddCut(kTPC,AliPID::kKaon,-2.,2.,0.,2.,kTRUE);
 466     AddCut(kTPC,AliPID::kProton,-2.,2.,0.,2.,kTRUE);
 467
 468   } else if (def==2) {
 469     // include 2sigma e TPC
 470     // 3sigma bands TOF
 471     // - exclude K,P
 472     AddCut(kTPC,AliPID::kElectron,-3.,3.);
 473     AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
 474     AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
 475
 476   } else if (def==3 || def==4) { // def3 and def4 are the same??
 477     // include 2sigma e TPC
 478     // 3sigma bands TOF
 479     // - exclude K 0<p<1
 480     // - exclude P 0<p<2
 481     AddCut(kTPC,AliPID::kElectron,2);
 482     AddCut(kTOF,AliPID::kKaon,-3.,3.,0.,1.,kTRUE);
 483     AddCut(kTOF,AliPID::kProton,-6.,6.,0.,1.,kTRUE);
 484     AddCut(kTOF,AliPID::kProton,-3.,3.,1.,2.,kTRUE);
 485
 486   } else if (def==5) {
 487     AddCut(kTPC,AliPID::kElectron,-0.5,3);
 488     AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
 489   } else if (def==6) {
 490     // lower cut TPC: parametrisation by HFE
 491     // upper cut TPC: 3 sigma
 492     // TOF ele band 3sigma 0<p<1.5GeV
 493     TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)", 0, 100);
 494     lowerCut->SetParameters(-2.7,-0.4357);
 495     AddCut(kTPC,AliPID::kElectron,lowerCut,3.);
 496     AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
 497   } else if (def==7) {
 498     // wide TPC cut
 499     // TOF ele band 3sigma 0<p<1.5GeV
 500     AddCut(kTPC,AliPID::kElectron,10.);
 501     AddCut(kTOF,AliPID::kElectron,-3,3,0,1.5);
 502   } else if (def==8) {
 503     // TOF 5 sigma inclusion if TOFpid available
 504     // this should reduce K,p,Pi to a large extent
 505     AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 506   } else if (def==9) {
 507     // lower cut TPC: parametrisation by HFE
 508     // upper cut TPC: 3 sigma
 509     // TOF 5 sigma inclusion if TOFpid available
 510     // this should reduce K,p,Pi to a large extent
 511     TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)", 0, 100);
 512     lowerCut->SetParameters(-2.65,-0.6757);
 513     AddCut(kTPC,AliPID::kElectron,lowerCut,4.);
 514     AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 515
 516   } else if (def==10) {
 517     AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 518     AddCut(kTPC,AliPID::kElectron,3.);
 519     AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
 520     AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
 521
 522   } else if (def==11) {
 523     // lower cut TPC: parametrisation by HFE
 524     // only use from period d on !!
 525     // upper cut TPC: 3 sigma
 526     // TOF ele band 3sigma 0<p<2.0GeV
 527     TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)+[2]", 0, 100);
 528     lowerCut->SetParameters(-3.718,-0.4,0.27);
 529     AddCut(kTPC,AliPID::kElectron,lowerCut,3.);
 530     AddCut(kTOF,AliPID::kElectron,-3,3,0,2.);
 531   } else if (def==12) {
 532     // lower cut TPC: parametrisation by HFE
 533     // only use from period d on !!
 534     // upper cut TPC: 3 sigma
 535     // TOF 5 sigma inclusion if TOFpid available
 536     // this should reduce K,p,Pi to a large extent
 537     TF1 *lowerCut=new TF1("lowerCut", "[0] * TMath::Exp([1]*x)+[2]", 0, 100);
 538     lowerCut->SetParameters(-3.718,-0.4,0.27);
 539     AddCut(kTPC,AliPID::kElectron,lowerCut,4.);
 540     AddCut(kTOF,AliPID::kElectron,-5,5,0,200,kFALSE,AliDielectronPID::kIfAvailable);
 541   }
 542
 543 }
 544
 545 //______________________________________________
 546 void AliDielectronPID::SetCorrVal(Double_t run)
 547 {
 548   //
 549   // set correction value for run
 550   //
 551   fgCorr=0.;
 552   fgCorrdEdx=1.;
 553
 554   if (fgFitCorr){
 555     fgCorr=fgFitCorr->Eval(run);
 556     if (run<fgFitCorr->GetX()[0]) fgCorr=fgFitCorr->GetY()[0];
 557     if (run>fgFitCorr->GetX()[fgFitCorr->GetN()-1]) fgCorr=fgFitCorr->GetY()[fgFitCorr->GetN()-1];
 558   }
 559
 560   if (fgdEdxRunCorr){
 561     fgCorrdEdx=fgdEdxRunCorr->Eval(run);
 562     if (run<fgdEdxRunCorr->GetX()[0]) fgCorrdEdx=fgdEdxRunCorr->GetY()[0];
 563     if (run>fgdEdxRunCorr->GetX()[fgFitCorr->GetN()-1]) fgCorrdEdx=fgdEdxRunCorr->GetY()[fgdEdxRunCorr->GetN()-1];
 564   }
 565 }
 566
 567 //______________________________________________
 568 Double_t AliDielectronPID::GetEtaCorr(const AliVTrack *track)
 569 {
 570   //
 571   // return eta correction
 572   //
 573   if (!fgFunEtaCorr) return 1;
 574   return fgFunEtaCorr->Eval(track->Eta());
 575 }