PWGGA/GammaConv/AliDalitzElectronCuts.cxx

   1
   2 /**************************************************************************
   3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   4  *                                                                        *
   5  * Authors: Svein Lindal, Daniel Lohner                                   *
   6  * Version 1.0                                                            *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17 ////////////////////////////////////////////////
  18 //---------------------------------------------
  19 // Class handling all kinds of selection cuts for
  20 // Gamma Conversion analysis
  21 //---------------------------------------------
  22 ////////////////////////////////////////////////
  23
  24
  25 #include "AliDalitzElectronCuts.h"
  26 #include "AliAODConversionPhoton.h"
  27 #include "AliKFVertex.h"
  28 #include "AliAODTrack.h"
  29 #include "AliESDtrack.h"
  30 #include "AliAnalysisManager.h"
  31 #include "AliInputEventHandler.h"
  32 #include "AliMCEventHandler.h"
  33 #include "AliAODHandler.h"
  34 #include "AliPIDResponse.h"
  35 #include "TH1.h"
  36 #include "TH2.h"
  37 #include "AliStack.h"
  38 #include "TObjString.h"
  39 #include "AliAODEvent.h"
  40 #include "AliESDEvent.h"
  41 #include "TList.h"
  42 class iostream;
  43
  44 using namespace std;
  45
  46 ClassImp(AliDalitzElectronCuts)
  47
  48
  49 const char* AliDalitzElectronCuts::fgkCutNames[AliDalitzElectronCuts::kNCuts] = {
  50 "GoodId",
  51 "ededxSigmaITSCut",
  52 "ededxSigmaTPCCut",
  53 "pidedxSigmaTPCCut",
  54 "piMinMomdedxSigmaTPCCut",
  55 "piMaxMomdedxSigmaTPCCut",
  56 "LowPRejectionSigmaCut",
  57 "kTOFelectronPID",
  58 "clsITSCut",
  59 "clsTPCCut",
  60 "EtaCut",
  61 "PsiPair",
  62 "RejectSharedElecGamma",
  63 "BackgroundScheme",
  64 "NumberOfRotations",
  65 "PtCut",
  66 "DCAcut",
  67 "MassCut",
  68 "kWeights"
  69 };
  70
  71 //________________________________________________________________________
  72 AliDalitzElectronCuts::AliDalitzElectronCuts(const char *name,const char *title) : AliAnalysisCuts(name,title),
  73     fHistograms(NULL),
  74     fPIDResponse(NULL),
  75     fesdTrackCuts(NULL),
  76     fEtaCut(0.9),
  77     fEtaShift(0.0),
  78     fDoEtaCut(kFALSE),
  79     fPtMinCut(0.0),
  80     fPtMaxCut(9999),
  81     fRadiusCut(1000.0),
  82     fPsiPairCut(0.45),
  83     fDeltaPhiCutMin(0.),
  84     fDeltaPhiCutMax(0.12),
  85     fMinClsTPC(0), // minimum clusters in the TPC
  86     fMinClsTPCToF(0), // minimum clusters to findable clusters
  87     fDodEdxSigmaITSCut(kFALSE),
  88     fDodEdxSigmaTPCCut(kTRUE),
  89     fDoTOFsigmaCut(kFALSE), // RRnewTOF
  90     fDoRejectSharedElecGamma(kFALSE),
  91     fDoPsiPairCut(kFALSE),
  92     fPIDnSigmaAboveElectronLineITS(100),
  93     fPIDnSigmaBelowElectronLineITS(-100),
  94     fPIDnSigmaAboveElectronLineTPC(100),
  95     fPIDnSigmaBelowElectronLineTPC(-100),
  96     fPIDnSigmaAbovePionLineTPC(0),
  97     fPIDnSigmaAbovePionLineTPCHighPt(-100),
  98     fTofPIDnSigmaAboveElectronLine(100), // RRnewTOF
  99     fTofPIDnSigmaBelowElectronLine(-100), // RRnewTOF
 100     fPIDMinPnSigmaAbovePionLineTPC(0),
 101     fPIDMaxPnSigmaAbovePionLineTPC(0),
 102     fDoKaonRejectionLowP(kFALSE),
 103     fDoProtonRejectionLowP(kFALSE),
 104     fDoPionRejectionLowP(kFALSE),
 105     fPIDnSigmaAtLowPAroundKaonLine(0),
 106     fPIDnSigmaAtLowPAroundProtonLine(0),
 107     fPIDnSigmaAtLowPAroundPionLine(0),
 108     fPIDMinPKaonRejectionLowP(1.5),
 109     fPIDMinPProtonRejectionLowP(2.0),
 110     fPIDMinPPionRejectionLowP(0.5),
 111     fUseCorrectedTPCClsInfo(kFALSE),
 112     fUseCrossedRows(kFALSE),
 113     fUseTOFpid(kFALSE),
 114     fRequireTOF(kFALSE),
 115     fUseTrackMultiplicityForBG(kFALSE),
 116     fBKGMethod(0),
 117     fnumberOfRotationEventsForBG(0),
 118     fDoMassCut(kFALSE),
 119     fDoMassMinCut(kFALSE),
 120     fMassCutLowPt(999.),
 121     fMassCutHighPt(999.),
 122     fMassCutPtMin(-100.0),
 123     fMassMinCut(-999.),
 124     fDoWeights(kFALSE),
 125     fCutString(NULL),
 126     hCutIndex(NULL),
 127     hdEdxCuts(NULL),
 128     hITSdEdxbefore(NULL),
 129     hITSdEdxafter(NULL),
 130     hTPCdEdxbefore(NULL),
 131     hTPCdEdxafter(NULL),
 132     hTPCdEdxSignalbefore(NULL),
 133     hTPCdEdxSignalafter(NULL),
 134     hTOFbefore(NULL),
 135     hTOFafter(NULL),
 136     hTrackDCAxyPtbefore(NULL),
 137     hTrackDCAxyPtafter(NULL),
 138     hTrackDCAzPtbefore(NULL),
 139     hTrackDCAzPtafter(NULL),
 140     hTrackNFindClsPtTPCbefore(NULL),
 141     hTrackNFindClsPtTPCafter(NULL)
 142    {
 143     InitPIDResponse();
 144     for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=0;}
 145     fCutString=new TObjString((GetCutNumber()).Data());
 146
 147    //fesdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");
 148    // Using standard function for setting Cuts
 149     Bool_t selectPrimaries=kFALSE;
 150     fesdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
 151 }
 152
 153 //________________________________________________________________________
 154 AliDalitzElectronCuts::~AliDalitzElectronCuts() {
 155     // Destructor
 156   //Deleting fHistograms leads to seg fault it it's added to output collection of a task
 157   // if(fHistograms)
 158   //    delete fHistograms;
 159   // fHistograms = NULL;
 160
 161    if(fCutString != NULL){
 162       delete fCutString;
 163       fCutString = NULL;
 164    }
 165
 166
 167 }
 168
 169 //________________________________________________________________________
 170 void AliDalitzElectronCuts::InitCutHistograms(TString name, Bool_t preCut,TString cutNumber){
 171
 172     // Initialize Cut Histograms for QA (only initialized and filled if function is called)
 173
 174      TH1::AddDirectory(kFALSE);
 175
 176      TString cutName = "";
 177
 178      if( cutNumber==""){
 179          cutName = GetCutNumber().Data();
 180      }
 181      else {
 182             cutName = cutNumber.Data();
 183      }
 184
 185     if(fHistograms != NULL){
 186         delete fHistograms;
 187         fHistograms=NULL;
 188     }
 189     if(fHistograms==NULL){
 190         fHistograms=new TList();
 191         if(name=="")fHistograms->SetName(Form("ElectronCuts_%s",cutName.Data()));
 192         else fHistograms->SetName(Form("%s_%s",name.Data(),cutName.Data()));
 193     }
 194
 195
 196     Int_t kDedxSignalbins = 200;
 197
 198      const Int_t kDCABins=62;
 199
 200      Double_t binsDCADummy[63]={-3.0,-2.7,-2.4,-2.1,-1.8,-1.5,-1.2,-0.9,-0.6,-0.3,-0.25,-0.2,-0.19,-0.18,-0.17,-0.16,-0.15,-0.14,-0.13,-0.12,-0.11,-0.10,-0.09,-0.08,-0.07,-0.06,-0.05,-0.04,-0.03,-0.02,-0.01,0.0,0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1,0.11,0.12,0.13,0.14,0.15,0.16,0.17,0.18,0.19,0.2,0.25,0.3,0.6,0.9,1.2,1.5,1.8,2.1,2.4,2.7,3.0};
 201
 202      const Int_t kPtBins=110;
 203      Double_t binsPtDummy[kPtBins+1];
 204      const Int_t kPBins = 109;
 205      Double_t binsPDummy[kPBins+1];
 206      binsPtDummy[0]=0.0;
 207      binsPDummy[0]=0.05;
 208
 209         for(Int_t i=1;i<kPtBins+1;i++)
 210         {
 211                 if(binsPtDummy[i-1]+0.05<1.01)
 212                         binsPtDummy[i]=binsPtDummy[i-1]+0.05;
 213                 else
 214                         binsPtDummy[i]=binsPtDummy[i-1]+0.1;
 215
 216         }
 217         for(Int_t i=1; i <kPBins+1;i++){
 218
 219                   if( binsPDummy[i-1]+0.05<1.01)
 220                         binsPDummy[i] = binsPDummy[i-1]+0.05;
 221                   else
 222                         binsPDummy[i] = binsPDummy[i-1]+0.1;
 223
 224         }
 225
 226
 227
 228     hCutIndex=new TH1F(Form("IsElectronSelected %s",cutName.Data()),"IsElectronSelected",10,-0.5,9.5);
 229     hCutIndex->GetXaxis()->SetBinLabel(kElectronIn+1,"in");
 230     hCutIndex->GetXaxis()->SetBinLabel(kNoTracks+1,"no tracks");
 231     hCutIndex->GetXaxis()->SetBinLabel(kTrackCuts+1,"Track cuts");
 232     hCutIndex->GetXaxis()->SetBinLabel(kdEdxCuts+1,"dEdx");
 233     hCutIndex->GetXaxis()->SetBinLabel(kElectronOut+1,"out");
 234     fHistograms->Add(hCutIndex);
 235
 236
 237
 238     // dEdx Cuts
 239     hdEdxCuts=new TH1F(Form("dEdxCuts %s",cutName.Data()),"dEdxCuts",10,-0.5,9.5);
 240     hdEdxCuts->GetXaxis()->SetBinLabel(1,"in");
 241     hdEdxCuts->GetXaxis()->SetBinLabel(2,"ITSelectron");
 242     hdEdxCuts->GetXaxis()->SetBinLabel(3,"TPCelectron");
 243     hdEdxCuts->GetXaxis()->SetBinLabel(4,"TPCpion");
 244     hdEdxCuts->GetXaxis()->SetBinLabel(5,"TPCpionhighp");
 245     hdEdxCuts->GetXaxis()->SetBinLabel(6,"TPCkaonlowprej");
 246     hdEdxCuts->GetXaxis()->SetBinLabel(7,"TPCprotonlowprej");
 247     hdEdxCuts->GetXaxis()->SetBinLabel(8,"TPCpionlowprej");
 248     hdEdxCuts->GetXaxis()->SetBinLabel(9,"TOFelectron");
 249     hdEdxCuts->GetXaxis()->SetBinLabel(10,"out");
 250     fHistograms->Add(hdEdxCuts);
 251
 252
 253
 254     TAxis *AxisBeforeITS  = NULL;
 255     TAxis *AxisBeforedEdx = NULL;
 256     TAxis *AxisBeforeTOF  = NULL;
 257     TAxis *AxisBeforedEdxSignal = NULL;
 258
 259     if(preCut){
 260
 261
 262        hITSdEdxbefore=new TH2F(Form("Electron_ITS_before %s",cutName.Data()),"ITS dEdx electron before" ,kPBins,binsPDummy,200,-10,10);
 263        fHistograms->Add(hITSdEdxbefore);
 264        AxisBeforeITS = hITSdEdxbefore->GetXaxis();
 265
 266        hTPCdEdxbefore=new TH2F(Form("Electron_dEdx_before %s",cutName.Data()),"dEdx electron before" ,kPBins,binsPDummy,200,-10,10);
 267        fHistograms->Add(hTPCdEdxbefore);
 268        AxisBeforedEdx = hTPCdEdxbefore->GetXaxis();
 269
 270        hTPCdEdxSignalbefore=new TH2F(Form("Electron_dEdxSignal_before %s",cutName.Data()),"dEdx electron signal before" ,kPBins,binsPDummy,kDedxSignalbins,0.0,200);
 271        fHistograms->Add(hTPCdEdxSignalbefore);
 272        AxisBeforedEdxSignal = hTPCdEdxSignalbefore->GetXaxis();
 273
 274        hTOFbefore=new TH2F(Form("Electron_TOF_before %s",cutName.Data()),"TOF electron before" ,kPBins,binsPDummy,200,-10,10);
 275        fHistograms->Add(hTOFbefore);
 276        AxisBeforeTOF = hTOFbefore->GetXaxis();
 277
 278        hTrackDCAxyPtbefore = new TH2F(Form("hTrack_DCAxy_Pt_before %s",cutName.Data()),"DCAxy Vs Pt of tracks before",kDCABins,binsDCADummy,kPtBins,binsPtDummy);
 279        fHistograms->Add(hTrackDCAxyPtbefore);
 280
 281        hTrackDCAzPtbefore  = new TH2F(Form("hTrack_DCAz_Pt_before %s",cutName.Data()), "DCAz  Vs Pt of tracks before",kDCABins,binsDCADummy,kPtBins,binsPtDummy);
 282        fHistograms->Add(hTrackDCAzPtbefore);
 283
 284        hTrackNFindClsPtTPCbefore = new TH2F(Form("hTrack_NFindCls_Pt_TPC_before %s",cutName.Data()),"Track: N Findable Cls TPC Vs Pt before",60,0,1.5,kPtBins,binsPtDummy);
 285        fHistograms->Add(hTrackNFindClsPtTPCbefore);
 286
 287
 288
 289     }
 290
 291
 292     hITSdEdxafter=new TH2F(Form("Electron_ITS_after %s",cutName.Data()),"ITS dEdx electron after" ,kPBins,binsPDummy,200, -10,10);
 293     fHistograms->Add(hITSdEdxafter);
 294
 295     hTPCdEdxafter=new TH2F(Form("Electron_dEdx_after %s",cutName.Data()),"dEdx electron after" ,kPBins,binsPDummy,200, -10,10);
 296     fHistograms->Add(hTPCdEdxafter);
 297
 298     hTPCdEdxSignalafter=new TH2F(Form("Electron_dEdxSignal_after %s",cutName.Data()),"dEdx electron signal after" ,kPBins,binsPDummy,kDedxSignalbins,0.0,200);
 299     fHistograms->Add(hTPCdEdxSignalafter);
 300
 301     hTOFafter=new TH2F(Form("Electron_TOF_after %s",cutName.Data()),"TOF electron after" ,kPBins,binsPDummy,200,-6,10);
 302     fHistograms->Add(hTOFafter);
 303
 304     hTrackDCAxyPtafter  = new TH2F(Form("hTrack_DCAxy_Pt_after %s",cutName.Data()),"DCAxy Vs Pt of tracks after",kDCABins,binsDCADummy,kPtBins,binsPtDummy);
 305     fHistograms->Add(hTrackDCAxyPtafter);
 306
 307     hTrackDCAzPtafter  = new TH2F(Form("hTrack_DCAz_Pt_after %s",cutName.Data()), "DCAz Vs Pt of tracks  after",kDCABins,binsDCADummy,kPtBins,binsPtDummy);
 308     fHistograms->Add(hTrackDCAzPtafter);
 309
 310     hTrackNFindClsPtTPCafter = new TH2F(Form("hTrack_NFindCls_Pt_TPC_after %s",cutName.Data()),"Track: N Findable Cls TPC Vs Pt after",60,0,1.5,kPtBins,binsPtDummy);
 311     fHistograms->Add(hTrackNFindClsPtTPCafter);
 312
 313
 314
 315     TAxis *AxisAfter = hTPCdEdxafter->GetXaxis();
 316     Int_t bins = AxisAfter->GetNbins();
 317     Double_t from = AxisAfter->GetXmin();
 318     Double_t to = AxisAfter->GetXmax();
 319     Double_t *newBins = new Double_t[bins+1];
 320     newBins[0] = from;
 321     Double_t factor = TMath::Power(to/from, 1./bins);
 322     for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
 323     AxisAfter->Set(bins, newBins);
 324     AxisAfter = hTOFafter->GetXaxis();
 325     AxisAfter->Set(bins, newBins);
 326     AxisAfter = hITSdEdxafter->GetXaxis();
 327     AxisAfter->Set(bins,newBins);
 328     AxisAfter = hTPCdEdxSignalafter->GetXaxis();
 329     AxisAfter->Set(bins,newBins);
 330
 331     if(preCut){
 332        AxisBeforeITS->Set(bins, newBins);
 333        AxisBeforedEdx->Set(bins, newBins);
 334        AxisBeforedEdxSignal->Set(bins,newBins);
 335        AxisBeforeTOF->Set(bins, newBins);
 336
 337     }
 338     delete [] newBins;
 339
 340     TH1::AddDirectory(kTRUE);
 341
 342     // Event Cuts and Info
 343 }
 344
 345
 346 //________________________________________________________________________
 347 Bool_t AliDalitzElectronCuts::InitPIDResponse(){
 348
 349 // Set Pointer to AliPIDResponse
 350
 351   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 352
 353   if(man) {
 354
 355     AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 356     fPIDResponse = (AliPIDResponse*)inputHandler->GetPIDResponse();
 357     if(fPIDResponse)return kTRUE;
 358
 359   }
 360
 361   return kFALSE;
 362 }
 363 ///________________________________________________________________________
 364 Bool_t AliDalitzElectronCuts::ElectronIsSelectedMC(Int_t labelParticle,AliStack *fMCStack)
 365 {
 366         if( labelParticle < 0 || labelParticle >= fMCStack->GetNtrack() ) return kFALSE;
 367         if( fMCStack->IsPhysicalPrimary(labelParticle) == kFALSE ) return kFALSE; //Ask Ana
 368
 369         TParticle* particle = fMCStack->Particle(labelParticle);
 370
 371         if( TMath::Abs( particle->GetPdgCode() ) != 11 )  return kFALSE;
 372
 373         if( fDoEtaCut ){
 374           if( particle->Eta() > (fEtaCut + fEtaShift) || particle->Eta() < (-fEtaCut + fEtaShift) )
 375           return kFALSE;
 376         }
 377
 378
 379 return kTRUE;
 380 }
 381
 382
 383 ///________________________________________________________________________
 384 Bool_t AliDalitzElectronCuts::ElectronIsSelected(AliESDtrack* lTrack)
 385 {
 386     //Selection of Reconstructed electrons
 387
 388
 389     Float_t b[2];
 390     Float_t bCov[3];
 391     lTrack->GetImpactParameters(b,bCov);
 392
 393     if (bCov[0]<=0 || bCov[2]<=0) {
 394         AliDebug(1, "Estimated b resolution lower or equal zero!");
 395         bCov[0]=0; bCov[2]=0;
 396     }
 397
 398
 399
 400     Float_t dcaToVertexXY = b[0];
 401     Float_t dcaToVertexZ  = b[1];
 402     Double_t clsToF = GetNFindableClustersTPC(lTrack);
 403
 404    if( hTrackDCAxyPtbefore) hTrackDCAxyPtbefore->Fill(dcaToVertexXY,lTrack->Pt());
 405    if( hTrackDCAzPtbefore ) hTrackDCAzPtbefore->Fill( dcaToVertexZ, lTrack->Pt());
 406    if( hTrackNFindClsPtTPCbefore ) hTrackNFindClsPtTPCbefore->Fill( clsToF, lTrack->Pt());
 407
 408
 409
 410     if(hCutIndex)hCutIndex->Fill(kElectronIn);
 411
 412     if (lTrack == NULL){
 413       if(hCutIndex)hCutIndex->Fill(kNoTracks);
 414          return kFALSE;
 415     }
 416
 417     if ( ! lTrack->GetConstrainedParam() ){
 418         return kFALSE;
 419     }
 420     AliVTrack * track = dynamic_cast<AliVTrack*>(lTrack);
 421
 422
 423     // Track Cuts
 424     if( !TrackIsSelected(lTrack) ){
 425          if(hCutIndex)hCutIndex->Fill(kTrackCuts);
 426          return kFALSE;
 427     }
 428
 429
 430     // dEdx Cuts
 431     if( ! dEdxCuts( track ) ) {
 432          if(hCutIndex)hCutIndex->Fill(kdEdxCuts);
 433          return kFALSE;
 434
 435     }
 436
 437     //Electron passed the cuts
 438     if(hCutIndex)hCutIndex->Fill(kElectronOut);
 439
 440     if( hTrackDCAxyPtafter)        hTrackDCAxyPtafter->Fill(dcaToVertexXY,lTrack->Pt());
 441     if( hTrackDCAzPtafter )        hTrackDCAzPtafter->Fill(dcaToVertexZ,lTrack->Pt());
 442     if( hTrackNFindClsPtTPCafter ) hTrackNFindClsPtTPCafter->Fill( clsToF, lTrack->Pt());
 443
 444
 445     return kTRUE;
 446 }
 447
 448 ///________________________________________________________________________
 449 Bool_t AliDalitzElectronCuts::TrackIsSelected(AliESDtrack* lTrack) {
 450     // Track Selection for Photon Reconstruction
 451
 452
 453     Double_t clsToF = GetNFindableClustersTPC(lTrack);
 454
 455
 456     if( ! fesdTrackCuts->AcceptTrack(lTrack) ){
 457
 458         return kFALSE;
 459     }
 460
 461     if( fDoEtaCut ) {
 462       if(  lTrack->Eta() > (fEtaCut + fEtaShift) || lTrack->Eta() < (-fEtaCut + fEtaShift) ) {
 463         return kFALSE;
 464       }
 465    }
 466
 467
 468    if( lTrack->Pt() < fPtMinCut || lTrack->Pt() > fPtMaxCut ) {
 469
 470         return kFALSE;
 471
 472    }
 473
 474
 475
 476     if( clsToF < fMinClsTPCToF){
 477     return kFALSE;
 478     }
 479
 480
 481
 482    return kTRUE;
 483 }
 484 ///________________________________________________________________________
 485 Bool_t AliDalitzElectronCuts::dEdxCuts(AliVTrack *fCurrentTrack){
 486
 487     // Electron Identification Cuts for Photon reconstruction
 488
 489     if(!fPIDResponse){  InitPIDResponse();  }// Try to reinitialize PID Response
 490     if(!fPIDResponse){  AliError("No PID Response"); return kFALSE;}// if still missing fatal error
 491
 492
 493
 494     //cout<<"dEdxCuts: //////////////////////////////////////////////////////////////////////////"<<endl;
 495
 496
 497
 498     Int_t cutIndex=0;
 499
 500     if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 501     if(hITSdEdxbefore)hITSdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));
 502     if(hTPCdEdxbefore)hTPCdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));
 503     if(hTPCdEdxSignalbefore)hTPCdEdxSignalbefore->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));
 504
 505
 506     cutIndex++;
 507
 508
 509                 if( fDodEdxSigmaITSCut == kTRUE ){
 510
 511
 512                         if( fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineITS ||
 513                                         fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)> fPIDnSigmaAboveElectronLineITS ){
 514
 515                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 516                                 return kFALSE;
 517       }
 518
 519                 }
 520
 521                 if(hITSdEdxafter)hITSdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));
 522
 523
 524                 cutIndex++;
 525
 526
 527                 if(fDodEdxSigmaTPCCut == kTRUE){
 528
 529
 530       // TPC Electron Line
 531       if( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineTPC ||
 532                                         fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaAboveElectronLineTPC){
 533
 534                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 535                                 return kFALSE;
 536       }
 537       cutIndex++;
 538
 539       // TPC Pion Line
 540                         if( fCurrentTrack->P()>fPIDMinPnSigmaAbovePionLineTPC && fCurrentTrack->P()<fPIDMaxPnSigmaAbovePionLineTPC ){
 541                                 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC     &&
 542                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC &&
 543                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPC){
 544
 545                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 546                                         return kFALSE;
 547                                 }
 548                         }
 549                         cutIndex++;
 550
 551                         // High Pt Pion rej
 552                         if( fCurrentTrack->P()>fPIDMaxPnSigmaAbovePionLineTPC ){
 553                                 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC &&
 554                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC&&
 555                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPCHighPt){
 556
 557                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 558                                         return kFALSE;
 559                                 }
 560                         }
 561
 562                         cutIndex++;
 563                 }
 564
 565                 else{ cutIndex+=3; }
 566
 567
 568                 if(   fDoKaonRejectionLowP == kTRUE   ){
 569
 570                         if( fCurrentTrack->P() < fPIDMinPKaonRejectionLowP ){
 571
 572                                 if( TMath::Abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kKaon))<fPIDnSigmaAtLowPAroundKaonLine){
 573
 574                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 575
 576                                         return kFALSE;
 577                                 }
 578                         }
 579                 }
 580                 cutIndex++;
 581
 582                 if(   fDoProtonRejectionLowP == kTRUE    ){
 583
 584                         if( fCurrentTrack->P()  < fPIDMinPProtonRejectionLowP ){
 585                                 if( TMath::Abs(   fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kProton))<fPIDnSigmaAtLowPAroundProtonLine){
 586
 587                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 588                                         return kFALSE;
 589                                 }
 590                         }
 591                 }
 592                 cutIndex++;
 593
 594                 if(fDoPionRejectionLowP == kTRUE){
 595                         if( fCurrentTrack->P() < fPIDMinPPionRejectionLowP ){
 596                                 if( TMath::Abs( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)) < fPIDnSigmaAtLowPAroundPionLine ){
 597
 598                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 599                                         return kFALSE;
 600                                 }
 601                         }
 602                 }
 603                 cutIndex++;
 604
 605
 606                 if( ( fCurrentTrack->GetStatus() & AliESDtrack::kTOFpid ) && ( !( fCurrentTrack->GetStatus() & AliESDtrack::kTOFmismatch) ) ){
 607                         if(hTOFbefore) hTOFbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));
 608                         if(fUseTOFpid){
 609         if(fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)>fTofPIDnSigmaAboveElectronLine ||
 610            fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)<fTofPIDnSigmaBelowElectronLine ){
 611                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 612                                         return kFALSE;
 613         }
 614                         }
 615                         if(hTOFafter)hTOFafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));
 616                 }
 617                 else if ( fRequireTOF == kTRUE ) {
 618
 619                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 620                         return kFALSE;
 621                 }
 622                 cutIndex++;
 623
 624                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
 625                 if(hTPCdEdxafter)hTPCdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));
 626                 if(hTPCdEdxSignalafter)hTPCdEdxSignalafter->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));
 627
 628                 return kTRUE;
 629 }
 630 ///________________________________________________________________________
 631
 632
 633 AliVTrack *AliDalitzElectronCuts::GetTrack(AliVEvent * event, Int_t label){
 634     //Returns pointer to the track with given ESD label
 635     //(Important for AOD implementation, since Track array in AOD data is different
 636     //from ESD array, but ESD tracklabels are stored in AOD Tracks)
 637
 638   AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);
 639   if(esdEvent) {
 640         if(label > event->GetNumberOfTracks() ) return NULL;
 641         AliESDtrack * track = esdEvent->GetTrack(label);
 642         return track;
 643
 644   } else {
 645         for(Int_t ii=0; ii<event->GetNumberOfTracks(); ii++) {
 646           AliVTrack * track = dynamic_cast<AliVTrack*>(event->GetTrack(ii));
 647
 648           if(track) {
 649                 if(track->GetID() == label) {
 650                   return track;
 651                 }
 652           }
 653         }
 654     }
 655
 656   cout << "track not found " << label << " " << event->GetNumberOfTracks() << endl;
 657   return NULL;
 658 }
 659 ///________________________________________________________________________
 660 Bool_t AliDalitzElectronCuts::RejectSharedElecGamma(TList *photons, Int_t indexEle){
 661
 662
 663      for(Int_t i = 0;i<photons->GetEntries();i++){
 664
 665       AliAODConversionPhoton *photonComp = (AliAODConversionPhoton*) photons->At(i);
 666
 667       Int_t posLabel = photonComp->GetTrackLabelPositive();
 668       Int_t negLabel = photonComp->GetTrackLabelNegative();
 669
 670       if( (photonComp->GetConversionRadius() < fRadiusCut) && (posLabel == indexEle || negLabel == indexEle) ){
 671         return kFALSE;
 672       }
 673      }
 674
 675    return kTRUE;
 676 }
 677 Bool_t AliDalitzElectronCuts::MassCut(Double_t pi0CandidatePt , Double_t vphotonCandidateMass){
 678
 679         if( pi0CandidatePt < fMassCutPtMin ){
 680
 681               if( vphotonCandidateMass < fMassCutLowPt ){
 682                     return kTRUE;
 683               }
 684
 685         }
 686         else{
 687
 688                if( vphotonCandidateMass < fMassCutHighPt ){
 689                     return kTRUE;
 690                }
 691
 692         }
 693
 694         return kFALSE;
 695
 696 }
 697
 698 Double_t AliDalitzElectronCuts::GetNFindableClustersTPC(AliESDtrack* lTrack){
 699
 700
 701   Double_t clsToF=0;
 702
 703   if( fUseCrossedRows == kFALSE ) {
 704
 705     if ( !fUseCorrectedTPCClsInfo ){
 706         if(lTrack->GetTPCNclsF()!=0){
 707
 708               clsToF = (Double_t)lTrack->GetNcls(1)/(Double_t)lTrack->GetTPCNclsF();
 709         }// Ncluster/Nfindablecluster
 710     }
 711     else {
 712
 713               //clsToF = lTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));
 714               clsToF = lTrack->GetTPCClusterInfo(2,0); //NOTE ask friederike
 715
 716     }
 717   } else  {
 718
 719          Float_t nCrossedRowsTPC = lTrack->GetTPCCrossedRows();
 720          clsToF = 1.0;
 721           if ( lTrack->GetTPCNclsF()>0 ) {
 722               clsToF = nCrossedRowsTPC / lTrack->GetTPCNclsF();
 723           }
 724     }
 725
 726   return clsToF;
 727
 728 }
 729
 730 /*
 731 Double_t AliDalitzElectronCuts::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg )
 732 {
 733 //
 734 // This angle is a measure for the contribution of the opening in polar
 735 // direction ??0 to the opening angle ?? Pair
 736 //
 737 // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC
 738 //      Master Thesis. Thorsten Dahms. 2005
 739 // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf
 740 //
 741         Double_t momPos[3];
 742         Double_t momNeg[3];
 743         if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );
 744         if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );
 745
 746         TVector3 posDaughter;
 747         TVector3 negDaughter;
 748
 749         posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );
 750         negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );
 751
 752         Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();
 753         Double_t openingAngle =  posDaughter.Angle( negDaughter );  //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );
 754
 755         if( openingAngle < 1e-20 ) return 0.;
 756
 757         Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );
 758
 759         return psiAngle;
 760 }*/
 761
 762 Bool_t AliDalitzElectronCuts::IsFromGammaConversion( Double_t psiPair, Double_t deltaPhi )
 763 {
 764 //
 765 // Returns true if it is a gamma conversion according to psi pair value
 766 //
 767         return ( (deltaPhi > fDeltaPhiCutMin  &&  deltaPhi < fDeltaPhiCutMax) &&
 768         TMath::Abs(psiPair) < ( fPsiPairCut - fPsiPairCut/fDeltaPhiCutMax * deltaPhi ) );
 769 }
 770
 771 ///________________________________________________________________________
 772 Bool_t AliDalitzElectronCuts::UpdateCutString(cutIds cutID, Int_t value) {
 773 ///Update the cut string (if it has been created yet)
 774
 775   if(fCutString && fCutString->GetString().Length() == kNCuts) {
 776          cout << "Updating cut id in spot number " << cutID << " to " << value << endl;
 777         fCutString->SetString(GetCutNumber());
 778   } else {
 779          cout << "fCutString not yet initialized, will not be updated" << endl;
 780         return kFALSE;
 781   }
 782  // cout << fCutString->GetString().Data() << endl;
 783   return kTRUE;
 784 }
 785
 786 ///________________________________________________________________________
 787 Bool_t AliDalitzElectronCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {
 788    // Initialize Cuts from a given Cut string
 789
 790 //   out<<"Set Cut Number: "<<analysisCutSelection.Data()<<endl;
 791   AliInfo(Form("Set ElectronCuts Number: %s",analysisCutSelection.Data()));
 792
 793   if(analysisCutSelection.Length()!=kNCuts) {
 794         AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));
 795         return kFALSE;
 796   }
 797   if(!analysisCutSelection.IsDigit()){
 798         AliError("Cut selection contains characters");
 799         return kFALSE;
 800   }
 801
 802   const char *cutSelection = analysisCutSelection.Data();
 803   #define ASSIGNARRAY(i)        fCuts[i] = cutSelection[i] - '0'
 804   for(Int_t ii=0;ii<kNCuts;ii++){
 805       ASSIGNARRAY(ii);
 806   }
 807
 808   // TestFlag
 809   if(fCuts[0] !=9){
 810     AliError("Analysis Cut Selection does not start with 9");
 811         PrintCuts();
 812     return kFALSE;
 813   }
 814
 815   // Set Individual Cuts
 816   for(Int_t ii=0;ii<kNCuts;ii++){
 817       if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;
 818   }
 819
 820   //PrintCuts();
 821
 822     return kTRUE;
 823 }
 824 ///________________________________________________________________________
 825 Bool_t AliDalitzElectronCuts::SetCut(cutIds cutID, const Int_t value) {
 826   ///Set individual cut ID
 827
 828   //cout << "Updating cut  " << fgkCutNames[cutID] << " (" << cutID << ") to " << value << endl;
 829
 830   switch (cutID) {
 831   case kgoodId:
 832         fCuts[kgoodId] = value;
 833         if(value != 9) {
 834           cout << "Error:: First value of cut string is wrong, aborting!!" << endl;
 835           return kFALSE;
 836         } else {
 837           return kTRUE;
 838         }
 839
 840   case kededxSigmaITSCut:
 841         if( SetITSdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented
 842           fCuts[kededxSigmaITSCut] = value;
 843           UpdateCutString(cutID, value);
 844           return kTRUE;
 845         } else return kFALSE;
 846
 847         case kededxSigmaTPCCut:
 848                 if( SetTPCdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented
 849                         fCuts[kededxSigmaTPCCut] = value;
 850                         UpdateCutString(cutID, value);
 851                         return kTRUE;
 852                 } else return kFALSE;
 853
 854   case kpidedxSigmaTPCCut:
 855                 if( SetTPCdEdxCutPionLine(value)) { //NOTE SetITSdEdxCutPionLine: To be implemented
 856                         fCuts[kpidedxSigmaTPCCut] = value;
 857                         UpdateCutString(cutID, value);
 858                         return kTRUE;
 859                 } else return kFALSE;
 860
 861   case kpiMinMomdedxSigmaTPCCut:
 862                 if( SetMinMomPiondEdxTPCCut(value)) {
 863                         fCuts[kpiMinMomdedxSigmaTPCCut] = value;
 864                         UpdateCutString(cutID, value);
 865                         return kTRUE;
 866                 } else return kFALSE;
 867
 868   case kpiMaxMomdedxSigmaTPCCut:
 869                 if( SetMaxMomPiondEdxTPCCut(value)) {
 870                         fCuts[kpiMaxMomdedxSigmaTPCCut] = value;
 871                         UpdateCutString(cutID, value);
 872                         return kTRUE;
 873                 } else return kFALSE;
 874
 875   case kLowPRejectionSigmaCut:
 876                 if( SetLowPRejectionCuts(value) ) {
 877                         fCuts[kLowPRejectionSigmaCut] = value;
 878                         UpdateCutString(cutID, value);
 879                         return kTRUE;
 880                 } else return kFALSE;
 881
 882
 883   case kTOFelectronPID:
 884                 if( SetTOFElectronPIDCut(value)) {
 885                         fCuts[kTOFelectronPID] = value;
 886                         UpdateCutString(cutID, value);
 887                         return kTRUE;
 888                 } else return kFALSE;
 889   case kclsITSCut:
 890                 if( SetITSClusterCut(value) ) {
 891                         fCuts[kclsITSCut] = value;
 892                         UpdateCutString(cutID, value);
 893                         return kTRUE;
 894                 } else return kFALSE;
 895   case kclsTPCCut:
 896                 if( SetTPCClusterCut(value)) {
 897                         fCuts[kclsTPCCut] = value;
 898                         UpdateCutString(cutID, value);
 899                         return kTRUE;
 900                 } else return kFALSE;
 901
 902   case ketaCut:
 903                 if( SetEtaCut(value)) {
 904                         fCuts[ketaCut] = value;
 905                         UpdateCutString(cutID, value);
 906                         return kTRUE;
 907                 } else return kFALSE;
 908   case kptCut:
 909                 if( SetPtCut(value)) {
 910                         fCuts[kptCut] = value;
 911                         UpdateCutString(cutID, value);
 912                         return kTRUE;
 913                 } else return kFALSE;
 914
 915   case kDCACut:
 916                 if( SetDCACut(value)) {
 917                         fCuts[kDCACut] = value;
 918                         UpdateCutString(cutID, value);
 919                         return kTRUE;
 920                 } else return kFALSE;
 921
 922
 923         case kPsiPair:
 924                 if( SetPsiPairCut(value)) {
 925                         fCuts[kPsiPair] = value;
 926                         UpdateCutString(cutID, value);
 927                         return kTRUE;
 928                 } else return kFALSE;
 929
 930   case kRejectSharedElecGamma:
 931                 if( SetRejectSharedElecGamma(value)) {
 932                         fCuts[kRejectSharedElecGamma] = value;
 933                         UpdateCutString(cutID, value);
 934           return kTRUE;
 935                 } else return kFALSE;
 936
 937   case kBackgroundScheme:
 938                 if( SetBackgroundScheme(value)) {
 939                         fCuts[kBackgroundScheme] = value;
 940                         UpdateCutString(cutID, value);
 941                         return kTRUE;
 942                 } else return kFALSE;
 943
 944   case kNumberOfRotations:
 945                 if( SetNumberOfRotations(value)) {
 946                         fCuts[kNumberOfRotations] = value;
 947                         UpdateCutString(cutID, value);
 948                         return kTRUE;
 949                 } else return kFALSE;
 950
 951   case kmassCut:
 952                 if( SetMassCut(value)) {
 953                         fCuts[kmassCut] = value;
 954                         UpdateCutString(cutID, value);
 955                         return kTRUE;
 956                 } else return kFALSE;
 957   case kWeights:
 958                 if( SetDoWeights(value)) {
 959                         fCuts[kWeights] = value;
 960                         UpdateCutString(cutID, value);
 961                         return kTRUE;
 962                 } else return kFALSE;
 963
 964
 965   case kNCuts:
 966                 cout << "Error:: Cut id out of range"<< endl;
 967                 return kFALSE;
 968   }
 969
 970   cout << "Error:: Cut id " << cutID << " not recognized "<< endl;
 971   return kFALSE;
 972
 973   //PrintCuts();
 974
 975 }
 976
 977 ///________________________________________________________________________
 978
 979 void AliDalitzElectronCuts::PrintCuts() {
 980     // Print out current Cut Selection
 981   for(Int_t ic = 0; ic < kNCuts; ic++) {
 982         printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);
 983   }
 984
 985 }
 986
 987 ///________________________________________________________________________
 988 Bool_t AliDalitzElectronCuts::SetITSdEdxCutElectronLine(Int_t ededxSigmaCut)
 989 {   // Set Cut
 990
 991         switch(ededxSigmaCut){
 992
 993         case 0:
 994                 fDodEdxSigmaITSCut = kFALSE;
 995                 fPIDnSigmaBelowElectronLineITS=-100;
 996                 fPIDnSigmaAboveElectronLineITS= 100;
 997                 break;
 998         case 1: // -10,10
 999                 fDodEdxSigmaITSCut = kTRUE;
1000                 fPIDnSigmaBelowElectronLineITS=-10;
1001                 fPIDnSigmaAboveElectronLineITS=10;
1002                 break;
1003         case 2: // -6,7
1004                 fDodEdxSigmaITSCut = kTRUE;
1005                 fPIDnSigmaBelowElectronLineITS=-6;
1006                 fPIDnSigmaAboveElectronLineITS=7;
1007                 break;
1008         case 3: // -5,5
1009                 fDodEdxSigmaITSCut = kTRUE;
1010                 fPIDnSigmaBelowElectronLineITS=-5;
1011                 fPIDnSigmaAboveElectronLineITS=5;
1012                 break;
1013         case 4: // -4,5
1014                 fDodEdxSigmaITSCut = kTRUE;
1015                 fPIDnSigmaBelowElectronLineITS=-4;
1016                 fPIDnSigmaAboveElectronLineITS=5;
1017                 break;
1018         case 5: // -3,5
1019                 fDodEdxSigmaITSCut = kTRUE;
1020                 fPIDnSigmaBelowElectronLineITS=-3;
1021                 fPIDnSigmaAboveElectronLineITS=5;
1022                 break;
1023         case 6: // -4,4
1024                 fDodEdxSigmaITSCut = kTRUE;
1025                 fPIDnSigmaBelowElectronLineITS=-4;
1026                 fPIDnSigmaAboveElectronLineITS=4;
1027                 break;
1028         case 7: // -2.5,4
1029                 fDodEdxSigmaITSCut = kTRUE;
1030                 fPIDnSigmaBelowElectronLineITS=-2.5;
1031                 fPIDnSigmaAboveElectronLineITS=4;
1032                 break;
1033         case 8: // -2,3.5
1034                 fDodEdxSigmaITSCut = kTRUE;
1035                 fPIDnSigmaBelowElectronLineITS=-2;
1036                 fPIDnSigmaAboveElectronLineITS=3.5;
1037                 break;
1038         default:
1039                 cout<<"Warning: ITSdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;
1040                 return kFALSE;
1041
1042         }
1043         return kTRUE;
1044 }
1045
1046 ///________________________________________________________________________
1047 Bool_t AliDalitzElectronCuts::SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut)
1048 {   // Set Cut
1049         switch(ededxSigmaCut){
1050
1051         case 0: fDodEdxSigmaTPCCut = kFALSE;
1052                 fPIDnSigmaBelowElectronLineTPC=-10;
1053                 fPIDnSigmaAboveElectronLineTPC=10;
1054                 break;
1055         case 1: // -10,10
1056                 fDodEdxSigmaTPCCut = kTRUE;
1057                 fPIDnSigmaBelowElectronLineTPC=-10;
1058                 fPIDnSigmaAboveElectronLineTPC=10;
1059                 break;
1060         case 2: // -6,7
1061                 fDodEdxSigmaTPCCut = kTRUE;
1062                 fPIDnSigmaBelowElectronLineTPC=-6;
1063                 fPIDnSigmaAboveElectronLineTPC=7;
1064                 break;
1065         case 3: // -5,5
1066                 fDodEdxSigmaTPCCut = kTRUE;
1067                 fPIDnSigmaBelowElectronLineTPC=-5;
1068                 fPIDnSigmaAboveElectronLineTPC=5;
1069                 break;
1070         case 4: // -4,5
1071                 fDodEdxSigmaTPCCut = kTRUE;
1072                 fPIDnSigmaBelowElectronLineTPC=-4;
1073                 fPIDnSigmaAboveElectronLineTPC=5;
1074                 break;
1075         case 5: // -3,5
1076                 fDodEdxSigmaTPCCut = kTRUE;
1077                 fPIDnSigmaBelowElectronLineTPC=-3;
1078                 fPIDnSigmaAboveElectronLineTPC=5;
1079                 break;
1080         case 6: // -4,4
1081                 fDodEdxSigmaTPCCut = kTRUE;
1082                 fPIDnSigmaBelowElectronLineTPC=-4;
1083                 fPIDnSigmaAboveElectronLineTPC=4;
1084                 break;
1085         case 7: // -2.5,4
1086                 fDodEdxSigmaTPCCut = kTRUE;
1087                 fPIDnSigmaBelowElectronLineTPC=-2.5;
1088                 fPIDnSigmaAboveElectronLineTPC=4;
1089                 break;
1090         case 8: // -2,3.5
1091                 fDodEdxSigmaTPCCut = kTRUE;
1092                 fPIDnSigmaBelowElectronLineTPC=-2;
1093                 fPIDnSigmaAboveElectronLineTPC=3.5;
1094                 break;
1095         default:
1096                 cout<<"Warning: TPCdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;
1097                 return kFALSE;
1098
1099         }
1100         return kTRUE;
1101 }
1102
1103 ///________________________________________________________________________
1104 Bool_t AliDalitzElectronCuts::SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut)
1105 {   // Set Cut
1106
1107         switch(pidedxSigmaCut){
1108
1109         case 0: fPIDnSigmaAbovePionLineTPC= 0;
1110                 fPIDnSigmaAbovePionLineTPCHighPt=-100;
1111                 break;
1112         case 1:  // -10
1113                 fPIDnSigmaAbovePionLineTPC=3.0;            //Update Sep-05-2013 from -10 to 3
1114                 fPIDnSigmaAbovePionLineTPCHighPt=-10;
1115                 break;
1116         case 2:  // 1
1117                 fPIDnSigmaAbovePionLineTPC=2;              //Update Sep-09-2013 from -1  to  2
1118                 fPIDnSigmaAbovePionLineTPCHighPt=-1;       //Update Sep-09-2013 from -10 to -1
1119                 break;
1120         case 3:   // 0
1121                 fPIDnSigmaAbovePionLineTPC=2;              //Update Sep-09-2013 from   0 to   2
1122                 fPIDnSigmaAbovePionLineTPCHighPt=0;        //Update Sep-09-2013 from -10 to   0
1123                 break;
1124         case 4:  // 1
1125                 fPIDnSigmaAbovePionLineTPC=1;
1126                 fPIDnSigmaAbovePionLineTPCHighPt=-10;
1127                 break;
1128         case 5:  // 1
1129                 fPIDnSigmaAbovePionLineTPC=2.;
1130                 fPIDnSigmaAbovePionLineTPCHighPt=-10;
1131                 break;
1132         case 6:  // 1
1133                 fPIDnSigmaAbovePionLineTPC=2.5;
1134                 fPIDnSigmaAbovePionLineTPCHighPt=-10;
1135                 break;
1136         case 7:
1137                 fPIDnSigmaAbovePionLineTPC = 2.0; // We need a bit less tight cut on dE/dx //Updated from 3.0 and -10 to +2.0 , +2.0
1138                 fPIDnSigmaAbovePionLineTPCHighPt = 2.0;
1139                 break;
1140         case 8:  // 1
1141                 fPIDnSigmaAbovePionLineTPC = 1.5;   // Updated May-16-2013 from 3.5 and -10 to +1.5, +1
1142                 fPIDnSigmaAbovePionLineTPCHighPt = 1.0;
1143                 break;
1144         case 9:  // 1
1145                 fPIDnSigmaAbovePionLineTPC=1.5;
1146                 fPIDnSigmaAbovePionLineTPCHighPt=-1.0;
1147                 break;
1148         default:
1149                 cout<<"Warning: pidedxSigmaCut not defined "<<pidedxSigmaCut<<endl;
1150                 return kFALSE;
1151         }
1152         return kTRUE;
1153 }
1154
1155 ///________________________________________________________________________
1156 Bool_t AliDalitzElectronCuts::SetMinMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut)
1157 {   // Set Cut
1158         switch(piMomdedxSigmaCut){
1159
1160         case 0: fPIDMinPnSigmaAbovePionLineTPC=0.;
1161                 break;
1162         case 1:  // 50.0 GeV
1163                 fPIDMinPnSigmaAbovePionLineTPC=50.;
1164                 break;
1165         case 2:  // 20.0 GeV
1166                 fPIDMinPnSigmaAbovePionLineTPC=20.;
1167                 break;
1168         case 3:  // 1.5 GeV
1169                 fPIDMinPnSigmaAbovePionLineTPC=1.5;
1170                 break;
1171         case 4:  // 1. GeV
1172                 fPIDMinPnSigmaAbovePionLineTPC=1.;
1173                 break;
1174         case 5:  // 0.5 GeV
1175                 fPIDMinPnSigmaAbovePionLineTPC=0.5;
1176                 break;
1177         case 6:  // 0.4 GeV
1178                 fPIDMinPnSigmaAbovePionLineTPC=0.4;
1179                 break;
1180         case 7:  // 0.3 GeV
1181                 fPIDMinPnSigmaAbovePionLineTPC=0.3;
1182                 break;
1183         case 8:  // 0.25 GeV
1184                 fPIDMinPnSigmaAbovePionLineTPC=0.25;
1185                 break;
1186         default:
1187                 cout<<"Warning: piMomdedxSigmaCut not defined "<<piMomdedxSigmaCut<<endl;
1188                 return kFALSE;
1189         }
1190         return kTRUE;
1191 }
1192 ///________________________________________________________________________
1193 Bool_t AliDalitzElectronCuts::SetITSClusterCut(Int_t clsITSCut){
1194
1195
1196         if( !fesdTrackCuts ) {
1197
1198                 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;
1199                 return kFALSE;
1200         }
1201
1202         switch(clsITSCut){
1203
1204         case 0: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);
1205                 break;
1206         case 1: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);
1207                 break;  //1 hit first layer of SPD
1208         case 2: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
1209                 break; //1 hit in any layer of SPD
1210         case 3: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);
1211                 fesdTrackCuts->SetMinNClustersITS(4);
1212                 // 4 hits in total in the ITS. At least 1 hit in the first layer of SPD
1213                 break;
1214         case 4: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
1215                 fesdTrackCuts->SetMinNClustersITS(3);
1216                 // 3 hits in total in the ITS. At least 1 hit in any layer of SPD
1217                 break;
1218         case 5: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
1219                 fesdTrackCuts->SetMinNClustersITS(4);
1220                 // 4 hits in total in the ITS. At least 1 hit in any layer of SPD
1221                 break;
1222         case 6: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
1223                 fesdTrackCuts->SetMinNClustersITS(5);
1224                 // 5 hits in total in the ITS. At least 1 hit in any layer of SPD
1225                 break;
1226         case 7: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);
1227                 fesdTrackCuts->SetMinNClustersITS(4);
1228                 break;
1229         default:
1230                 cout<<"Warning: clsITSCut not defined "<<clsITSCut<<endl;
1231                 return kFALSE;
1232         }
1233
1234 return kTRUE;
1235 }
1236
1237 ///________________________________________________________________________
1238 Bool_t AliDalitzElectronCuts::SetTPCClusterCut(Int_t clsTPCCut)
1239 {   // Set Cut
1240         switch(clsTPCCut){
1241         case 0: // 0
1242                 fMinClsTPC= 0.;
1243                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1244                 break;
1245         case 1:  // 70
1246                 fMinClsTPC= 70.;
1247                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1248                 break;
1249         case 2:  // 80
1250                 fMinClsTPC= 80.;
1251                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1252                 break;
1253         case 3:  // Changed 2014-02-04  before fMinClsTPC = 50.;
1254                 fMinClsTPCToF = 0.8;
1255                 fesdTrackCuts->SetMinNCrossedRowsTPC(70);
1256                 fesdTrackCuts->SetMinNClustersTPC(0);
1257                 fUseCrossedRows = kTRUE;
1258                 break;
1259         case 4:  // 0% of findable clusters
1260                 fMinClsTPC= 70.;
1261                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1262                 fMinClsTPCToF= 0.0;
1263                 fUseCorrectedTPCClsInfo=0;
1264                 break;
1265         case 5:  // 35% of findable clusters
1266                 fMinClsTPC = 70.;
1267                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1268                 fMinClsTPCToF= 0.35;
1269                 fUseCorrectedTPCClsInfo=0;
1270                 break;
1271         case 6:  // 60% of findable clusters
1272                 fMinClsTPC= 70.;
1273                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1274                 fMinClsTPCToF= 0.6;
1275                 fUseCorrectedTPCClsInfo=0;
1276                 break;
1277         case 7:  // 60% Changed 2014-02-04 before fMinClsTPC = 0.7 fUseCorrectedTPCClsInfo = 0
1278                  // Changed 2014-02-04  before fMinClsTPC = 50.;
1279                 fMinClsTPCToF = 0.6;
1280                 fesdTrackCuts->SetMinNCrossedRowsTPC(70);
1281                 fesdTrackCuts->SetMinNClustersTPC(0);
1282                 fUseCrossedRows = kTRUE;
1283                 break;
1284         case 8: fMinClsTPC = 0.;
1285                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1286                 fMinClsTPCToF= 0.35;
1287                 fUseCorrectedTPCClsInfo=0;
1288                 break;
1289         case 9:  // 35% of findable clusters
1290                 fMinClsTPC = 70.;
1291                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1292                 fMinClsTPCToF= 0.35;
1293                 fUseCorrectedTPCClsInfo=1;
1294                 break;
1295
1296         default:
1297                 cout<<"Warning: clsTPCCut not defined "<<clsTPCCut<<endl;
1298                 return kFALSE;
1299         }
1300         return kTRUE;
1301 }
1302
1303 ///________________________________________________________________________
1304 Bool_t AliDalitzElectronCuts::SetEtaCut(Int_t etaCut)
1305 {
1306   // Set eta Cut
1307         switch(etaCut){
1308         case 0:
1309                 fEtaCut = 100.;
1310                 fDoEtaCut = kFALSE;
1311                 break;
1312         case 1: // 1.4
1313                 fEtaCut = 1.4;
1314                 fDoEtaCut = kTRUE;
1315                 break;
1316         case 2: // 1.2
1317                 fEtaCut = 1.2;
1318                 fDoEtaCut = kTRUE;
1319                 break;
1320         case 3: // 0.9
1321                 fEtaCut = 0.9;
1322                 fDoEtaCut = kTRUE;
1323                 break;
1324         case 4: // 0.8
1325                 fEtaCut = 0.8;
1326                 fDoEtaCut = kTRUE;
1327                 break;
1328         case 5: // 0.75
1329                 fEtaCut = 0.75;
1330                 fDoEtaCut = kTRUE;
1331                 break;
1332         case 6: //0.6
1333                 fEtaCut = 0.6; //changed from 0.4 to 0.6 2013.06.10
1334                 fDoEtaCut = kTRUE;
1335                 break;
1336         case 7: //0.5
1337                 fEtaCut = 0.5; //changed from 0.3 to 0.5 2013.06.10
1338                 fDoEtaCut = kTRUE;
1339                 break;
1340         case 8: fEtaCut = 0.4;
1341                 fDoEtaCut = kTRUE;
1342                 break;
1343         case 9: fEtaCut = 0.65;
1344                 fDoEtaCut = kTRUE;
1345                 break;
1346         default:
1347                 cout<<"Warning: EtaCut not defined "<<etaCut<<endl;
1348                 return kFALSE;
1349         }
1350         return kTRUE;
1351 }
1352
1353 ///________________________________________________________________________
1354 Bool_t AliDalitzElectronCuts::SetPtCut(Int_t ptCut)
1355 {
1356         // Set Pt Cut
1357          //0.1GeV, 0.125 GeV, 0.15 GeV
1358
1359         switch(ptCut){
1360
1361         case 0: fPtMinCut = 0.075;
1362                 fPtMaxCut = 9999;
1363                 break;
1364         case 1:  // 0.1
1365                 fPtMinCut  = 0.1;
1366                 fPtMaxCut  = 9999;
1367                 break;
1368         case 2:  // 0.125 GeV
1369                 fPtMinCut = 0.125;
1370                 fPtMaxCut = 9999;
1371                 break;
1372         case 3: // 0.15 GeV
1373                 fPtMinCut = 0.15;
1374                 fPtMaxCut = 9999;
1375                 break;
1376                 // 0.5 - 0.7
1377         case 4: fPtMinCut = 0.5;
1378                 fPtMaxCut = 0.7;
1379                 break;
1380         default:
1381                 cout<<"Warning: PtCut not defined "<<ptCut<<endl;
1382                 return kFALSE;
1383         }
1384         return kTRUE;
1385 }
1386
1387
1388 ///________________________________________________________________________
1389 Bool_t AliDalitzElectronCuts::SetDCACut(Int_t dcaCut)
1390 {
1391   // Set DCA Cut
1392
1393         if( !fesdTrackCuts ) {
1394
1395                 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;
1396                 return kFALSE;
1397         }
1398
1399         switch(dcaCut){
1400
1401         case 0:
1402                 //Open cuts//
1403                 fesdTrackCuts->SetMaxDCAToVertexZ(1000);
1404                 fesdTrackCuts->SetMaxDCAToVertexXY(1000);
1405                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
1406                 break;
1407
1408         case 1:
1409                 fesdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
1410                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
1411
1412                 break;
1413         case 2: fesdTrackCuts->SetMaxDCAToVertexZ(2);
1414                 fesdTrackCuts->SetMaxDCAToVertexXY(1);
1415                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
1416                 break;
1417
1418         case 3: fesdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0105+0.0350/pt^1.1");
1419                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
1420                 break;
1421
1422         default:
1423                 cout<<"Warning: dcaCut not defined "<<dcaCut<<endl;
1424                 return kFALSE;
1425         }
1426         return kTRUE;
1427 }
1428
1429
1430
1431
1432 ///________________________________________________________________________
1433 Bool_t AliDalitzElectronCuts::SetMaxMomPiondEdxTPCCut(Int_t piMaxMomdedxSigmaCut)
1434 {   // Set Cut
1435    switch(piMaxMomdedxSigmaCut){
1436
1437          case 0:
1438                  fPIDMaxPnSigmaAbovePionLineTPC=0.;
1439                  break;
1440          case 1:  // 100. GeV
1441                  fPIDMaxPnSigmaAbovePionLineTPC=100.;
1442                  break;
1443          case 2:  // 5. GeV
1444                  fPIDMaxPnSigmaAbovePionLineTPC=5.;
1445                         break;
1446          case 3:  // 4. GeV
1447                  fPIDMaxPnSigmaAbovePionLineTPC=4.;
1448                  break;
1449          case 4:  // 3.5 GeV
1450                  fPIDMaxPnSigmaAbovePionLineTPC=3.5;
1451                  break;
1452          case 5:  // 3. GeV
1453                  fPIDMaxPnSigmaAbovePionLineTPC=3.;
1454                  break;
1455          default:
1456                  cout<<"Warning: piMaxMomdedxSigmaCut not defined "<<piMaxMomdedxSigmaCut<<endl;
1457                  return kFALSE;
1458          }
1459          return kTRUE;
1460 }
1461
1462 ///________________________________________________________________________
1463 Bool_t AliDalitzElectronCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)
1464 {   // Set Cut
1465         switch(LowPRejectionSigmaCut){
1466         case 0:  //
1467                 fDoKaonRejectionLowP=kFALSE;
1468                 fDoProtonRejectionLowP=kFALSE;
1469                 fDoPionRejectionLowP=kFALSE;
1470                 fPIDnSigmaAtLowPAroundKaonLine=0;
1471                 fPIDnSigmaAtLowPAroundProtonLine=0;
1472                 fPIDnSigmaAtLowPAroundPionLine=0;
1473                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1474                 break;
1475         case 1:  //
1476                 fDoKaonRejectionLowP=kTRUE;
1477                 fDoProtonRejectionLowP=kTRUE;
1478                 fDoPionRejectionLowP=kTRUE;
1479                 fPIDnSigmaAtLowPAroundKaonLine=0.5;
1480                 fPIDnSigmaAtLowPAroundProtonLine=0.5;
1481                 fPIDnSigmaAtLowPAroundPionLine=0.5;
1482                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1483                 break;
1484         case 2:  //
1485                 fDoKaonRejectionLowP=kTRUE;
1486                 fDoProtonRejectionLowP=kTRUE;
1487                 fDoPionRejectionLowP=kTRUE;
1488                 fPIDnSigmaAtLowPAroundKaonLine=1.0;
1489                 fPIDnSigmaAtLowPAroundProtonLine=1.0;
1490                 fPIDnSigmaAtLowPAroundPionLine=1.0;
1491                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1492                 break;
1493         case 3:  //
1494                 fDoKaonRejectionLowP=kTRUE;
1495                 fDoProtonRejectionLowP=kTRUE;
1496                 fDoPionRejectionLowP=kTRUE;
1497                 fPIDnSigmaAtLowPAroundKaonLine=1.5;
1498                 fPIDnSigmaAtLowPAroundProtonLine=1.5;
1499                 fPIDnSigmaAtLowPAroundPionLine=1.5;
1500                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1501                 break;
1502         case 4:  //
1503                 fDoKaonRejectionLowP=kTRUE;
1504                 fDoProtonRejectionLowP=kTRUE;
1505                 fDoPionRejectionLowP=kTRUE;
1506                 fPIDnSigmaAtLowPAroundKaonLine=2.0;
1507                 fPIDnSigmaAtLowPAroundProtonLine=2.0;
1508                 fPIDnSigmaAtLowPAroundPionLine=2.0;
1509                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1510                 break;
1511         case 5:  //
1512                 fDoKaonRejectionLowP=kTRUE;
1513                 fDoProtonRejectionLowP=kTRUE;
1514                 fDoPionRejectionLowP=kTRUE;
1515                 fPIDnSigmaAtLowPAroundKaonLine=2.0;
1516                 fPIDnSigmaAtLowPAroundProtonLine=2.0;
1517                 fPIDnSigmaAtLowPAroundPionLine=2.5;
1518                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1519                 break;
1520         case 6:  //
1521                 fDoKaonRejectionLowP=kTRUE;
1522                 fDoProtonRejectionLowP=kTRUE;
1523                 fDoPionRejectionLowP=kTRUE;
1524                 fPIDnSigmaAtLowPAroundKaonLine=0.;
1525                 fPIDnSigmaAtLowPAroundProtonLine=0.;
1526                 fPIDnSigmaAtLowPAroundPionLine=2.;
1527                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1528                 break;
1529         case 7: //
1530                 fDoKaonRejectionLowP=kFALSE;
1531                 fDoProtonRejectionLowP=kFALSE;
1532                 fDoPionRejectionLowP=kTRUE;
1533                 fPIDnSigmaAtLowPAroundKaonLine=0.0;
1534                 fPIDnSigmaAtLowPAroundProtonLine=0.0;
1535                 fPIDnSigmaAtLowPAroundPionLine=1.0;
1536                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1537                 break;
1538         case 8:
1539                 fDoKaonRejectionLowP=kFALSE;
1540                 fDoProtonRejectionLowP=kFALSE;
1541                 fDoPionRejectionLowP=kTRUE;
1542                 fPIDnSigmaAtLowPAroundKaonLine=0.;
1543                 fPIDnSigmaAtLowPAroundProtonLine=0.;
1544                 fPIDnSigmaAtLowPAroundPionLine=0.5;
1545                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1546                 break;
1547         default:
1548                 cout<<"Warning: LowPRejectionSigmaCut not defined "<<LowPRejectionSigmaCut<<endl;
1549                 return kFALSE;
1550         }
1551         return kTRUE;
1552 }
1553
1554 ///________________________________________________________________________
1555 Bool_t AliDalitzElectronCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){
1556     // Set Cut
1557         switch(TOFelectronPID){ // RRnewTOF start //////////////////////////////////////////////////////////////////////////
1558         case 0: // no cut
1559                 fRequireTOF = kFALSE;
1560                 fUseTOFpid = kFALSE;
1561                 fTofPIDnSigmaBelowElectronLine=-100;
1562                 fTofPIDnSigmaAboveElectronLine=100;
1563                 break;
1564         case 1: // -7,7
1565                 fRequireTOF = kFALSE;
1566                 fUseTOFpid = kTRUE;
1567                 fTofPIDnSigmaBelowElectronLine=-7;
1568                 fTofPIDnSigmaAboveElectronLine=7;
1569                 break;
1570         case 2: // -5,5
1571                 fRequireTOF = kFALSE;
1572                 fUseTOFpid = kTRUE;
1573                 fTofPIDnSigmaBelowElectronLine=-5;
1574                 fTofPIDnSigmaAboveElectronLine=5;
1575                 break;
1576         case 3: // -3,5
1577                 fRequireTOF = kFALSE;
1578                 fUseTOFpid = kTRUE;
1579                 fTofPIDnSigmaBelowElectronLine=-3;
1580                 fTofPIDnSigmaAboveElectronLine=5;
1581                 break;
1582         case 4: // -2,3
1583                 fRequireTOF = kFALSE;
1584                 fUseTOFpid = kTRUE;
1585                 fTofPIDnSigmaBelowElectronLine=-2;
1586                 fTofPIDnSigmaAboveElectronLine=3;
1587                 break;
1588         case 5: // -3, 3 TOF mandatory
1589                 fRequireTOF = kTRUE;
1590                 fUseTOFpid  = kTRUE;
1591                 fTofPIDnSigmaBelowElectronLine= -3;
1592                 fTofPIDnSigmaAboveElectronLine=  3;
1593                 break;
1594         default:
1595         cout<<"Warning: TOFElectronCut not defined "<<TOFelectronPID<<endl;
1596         return kFALSE;
1597     } //////////////////////// RRnewTOF end //////////////////////////////////////////////////////////////////////////
1598     return kTRUE;
1599 }
1600 ///_______________________________________________________________________________
1601
1602 Bool_t AliDalitzElectronCuts::SetPsiPairCut(Int_t psiCut) {
1603
1604
1605   switch(psiCut) {
1606   case 0:
1607         fDoPsiPairCut = kFALSE;
1608         fPsiPairCut = 10000.; //
1609         fDeltaPhiCutMin = -1000.;
1610         fDeltaPhiCutMax =  1000.;
1611
1612         break;
1613   case 1:
1614         fDoPsiPairCut = kTRUE;
1615         fPsiPairCut = 0.45; // Standard
1616         fDeltaPhiCutMin = 0.0;
1617         fDeltaPhiCutMax = 0.12;
1618         break;
1619   case 2:
1620         fDoPsiPairCut = kTRUE;
1621         fPsiPairCut = 0.60;
1622         fDeltaPhiCutMin = 0.0;
1623         fDeltaPhiCutMax = 0.12;
1624         break;
1625   case 3:
1626         fDoPsiPairCut = kTRUE;
1627         fPsiPairCut = 0.52;
1628         fDeltaPhiCutMin = 0.0;
1629         fDeltaPhiCutMax = 0.12;
1630         break;
1631   case 4:
1632         fDoPsiPairCut = kTRUE;
1633         fPsiPairCut = 0.30;
1634         fDeltaPhiCutMin = 0.0;
1635         fDeltaPhiCutMax = 0.12;
1636         break;
1637
1638   default:
1639       cout<<"Warning: PsiPairCut not defined "<<fPsiPairCut<<endl;
1640       return kFALSE;
1641   }
1642
1643   return kTRUE;
1644 }
1645
1646 ///_______________________________________________________________________________
1647 Bool_t AliDalitzElectronCuts::SetRejectSharedElecGamma(Int_t RCut) {
1648
1649
1650   switch(RCut) {
1651   case 0:
1652         fDoRejectSharedElecGamma = kFALSE;
1653         fRadiusCut = 10000; //
1654         break;
1655   case 1:
1656         fDoRejectSharedElecGamma = kTRUE;
1657         fRadiusCut = 2.0; // cm
1658         break;
1659   case 2:
1660         fDoRejectSharedElecGamma = kTRUE;
1661         fRadiusCut = 3.0; // Standard
1662         break;
1663   case 3:
1664         fDoRejectSharedElecGamma = kTRUE;
1665         fRadiusCut = 4.0; //
1666         break;
1667   case 4:
1668         fDoRejectSharedElecGamma = kTRUE;
1669         fRadiusCut = 5.0; //
1670         break;
1671   case 5:
1672         fDoRejectSharedElecGamma = kTRUE;
1673         fRadiusCut = 10.0; //
1674         break;
1675   case 6:
1676         fDoRejectSharedElecGamma = kTRUE;
1677         fRadiusCut = 15.0; //
1678         break;
1679   default:
1680       cout<<"Warning: PsiPairCut not defined "<<fDoRejectSharedElecGamma<<endl;
1681       return kFALSE;
1682   }
1683
1684   return kTRUE;
1685 }
1686 ///__________________________________________________________________________
1687 Bool_t AliDalitzElectronCuts::SetBackgroundScheme(Int_t BackgroundScheme){
1688
1689     // Set Cut
1690     switch(BackgroundScheme){
1691
1692     case 0: //Rotation
1693             fBKGMethod = 0;
1694             fUseTrackMultiplicityForBG = kFALSE;
1695         break;
1696     case 1: // mixed event with V0 multiplicity
1697             fBKGMethod  = 1;
1698             fUseTrackMultiplicityForBG = kFALSE;
1699         break;
1700     case 2: // mixed event with track multiplicity
1701             fUseTrackMultiplicityForBG = kTRUE;
1702             fBKGMethod  = 1;
1703         break;
1704     case 3: //Rotation
1705            fUseTrackMultiplicityForBG = kFALSE;
1706             fBKGMethod  = 2;
1707         break;
1708     case 4: //Rotation
1709             fUseTrackMultiplicityForBG = kTRUE;
1710             fBKGMethod  = 2;
1711         break;
1712     case 5: fUseTrackMultiplicityForBG = kTRUE;
1713             fBKGMethod  = 3;
1714         break;
1715
1716     default:
1717         cout<<"Warning: BackgroundScheme not defined "<<BackgroundScheme<<endl;
1718         return kFALSE;
1719     }
1720     return kTRUE;
1721 }
1722
1723 ///________________________________________________________________________
1724 Bool_t AliDalitzElectronCuts::SetNumberOfRotations(Int_t NumberOfRotations)
1725 {   // Set Cut
1726     switch(NumberOfRotations){
1727     case 0:
1728         fnumberOfRotationEventsForBG = 5;
1729         break;
1730     case 1:
1731         fnumberOfRotationEventsForBG = 10;
1732         break;
1733     case 2:
1734         fnumberOfRotationEventsForBG = 15;
1735         break;
1736     case 3:
1737         fnumberOfRotationEventsForBG = 20;
1738         break;
1739     case 4:
1740         fnumberOfRotationEventsForBG = 2;
1741         break;
1742     case 5:
1743         fnumberOfRotationEventsForBG = 50;
1744         break;
1745     case 6:
1746         fnumberOfRotationEventsForBG = 80;
1747         break;
1748     case 7:
1749         fnumberOfRotationEventsForBG = 100;
1750         break;
1751     default:
1752         cout<<"Warning: NumberOfRotations not defined "<<NumberOfRotations<<endl;
1753         return kFALSE;
1754     }
1755     return kTRUE;
1756 }
1757
1758
1759
1760 ///________________________________________________________________________
1761 Bool_t AliDalitzElectronCuts::SetDoWeights(Int_t opc)
1762 {   // Set Cut
1763     switch(opc){
1764
1765     case 0:             fDoWeights = kFALSE;
1766                         break;
1767     case 1:             fDoWeights = kTRUE;
1768                         break;
1769     default:
1770                         cout<<"Warning: Weights option not defined "<<opc<<endl;
1771                         return kFALSE;
1772     }
1773     return kTRUE;
1774 }
1775 ///________________________________________________________________________
1776 Bool_t AliDalitzElectronCuts::SetMassCut(Int_t massCut)
1777 {   // Set Cut
1778     switch(massCut){
1779
1780     case 0:
1781
1782                         fMassCutPtMin  = -999.; //GeV
1783                         fMassCutLowPt  =  999.; //GeV/c^2
1784                         fMassCutHighPt =  999.; //GeV/c^2
1785                         fMassMinCut = -999;
1786                         fDoMassCut = kFALSE;
1787                         fDoMassMinCut = kFALSE;
1788                         break;
1789     case 1:
1790                         //fMassCut = 0.135;             //GeV/c^2
1791                         fMassCutPtMin  = -999.; //GeV
1792                         fMassCutLowPt  = 0.135; //GeV/c^2
1793                         fMassCutHighPt = 0.135; //GeV/c^2
1794                         fMassMinCut = -999;
1795                         fDoMassCut = kTRUE;
1796                         fDoMassMinCut = kFALSE;
1797                         break;
1798     case 2:
1799                         //fMassCut = 0.100;     //GeV/c^2
1800                         fMassCutPtMin  = -999.; //GeV
1801                         fMassCutLowPt  = 0.100; //GeV/c^2
1802                         fMassCutHighPt = 0.100; //GeV/c^2
1803                         fMassMinCut = -999;
1804                         fDoMassCut = kTRUE;
1805                         fDoMassMinCut = kFALSE;
1806                         break;
1807     case 3:
1808                         /*fMassCut = 0.075;     //GeV/c^2 Changed from Feb 25
1809                         fMassCutPtMin  = -999.; //GeV
1810                         fMassCutLowPt  = 0.075; //GeV/c^2
1811                         fMassCutHighPt = 0.075; //GeV/c^2
1812                         fDoMassCut = kTRUE;
1813                         fDoMassMinCut = kFALSE;*/
1814                         fMassCutPtMin  = 1.0;   //GeV
1815                         fMassCutLowPt  = 0.015; //GeV/c^2
1816                         fMassCutHighPt = 0.035; //GeV/c^2
1817                         fMassMinCut    = 0.002;
1818                         fDoMassCut = kTRUE;
1819                         fDoMassMinCut = kTRUE;
1820                         break;
1821     case 4:
1822                         //fMassCut = 0.050;     //GeV/c^2
1823                         fMassCutPtMin  = -999.; //GeV
1824                         fMassCutLowPt  = 0.050; //GeV/c^2
1825                         fMassCutHighPt = 0.050; //GeV/c^2
1826                         fMassMinCut = -999;
1827                         fDoMassCut = kTRUE;
1828                         fDoMassMinCut = kFALSE;
1829                         break;
1830     case 5:
1831
1832                         fMassCutPtMin  = -999.; //GeV
1833                         fMassCutLowPt  = 0.035; //GeV/c^2
1834                         fMassCutHighPt = 0.035; //GeV/c^2
1835                         fMassMinCut = -999;
1836                         fDoMassCut = kTRUE;
1837                         fDoMassMinCut = kFALSE;
1838                         break;
1839     case 6:
1840                         fMassCutPtMin  = -999.; //GeV
1841                         fMassCutLowPt  = 0.015; //GeV/c^2
1842                         fMassCutHighPt = 0.015; //GeV/c^2
1843                         fMassMinCut = -999;
1844                         fDoMassCut = kTRUE;
1845                         fDoMassMinCut = kFALSE;
1846                         break;
1847     case 7:             fMassCutPtMin  = 1.0;   //GeV
1848                         fMassCutLowPt  = 0.015; //GeV/c^2
1849                         fMassCutHighPt = 0.035; //GeV/c^2
1850                         fMassMinCut = -999;
1851                         fDoMassCut = kTRUE;
1852                         fDoMassMinCut = kFALSE;
1853                         break;
1854     case 8:             fMassCutPtMin  = 1.0;   //GeV
1855                         fMassCutLowPt  = 0.015; //GeV/c^2
1856                         fMassCutHighPt = 0.050; //GeV/c^2
1857                         fMassMinCut = -999;
1858                         fDoMassCut = kTRUE;
1859                         fDoMassMinCut = kFALSE;
1860                         break;
1861     case 9:             fMassCutPtMin  = 1.0;   //GeV
1862                         fMassCutLowPt  = 0.025; //GeV/c^2
1863                         fMassCutHighPt = 0.035; //GeV/c^2
1864                         fMassMinCut = -999;
1865                         fDoMassCut = kTRUE;
1866                         fDoMassMinCut = kFALSE;
1867                         break;
1868     default:
1869                         cout<<"Warning: MassCut not defined "<<massCut<<endl;
1870                         return kFALSE;
1871     }
1872     return kTRUE;
1873 }
1874
1875
1876
1877 ///________________________________________________________________________
1878 TString AliDalitzElectronCuts::GetCutNumber(){
1879     // returns TString with current cut number
1880   TString a(kNCuts);
1881   for(Int_t ii=0;ii<kNCuts;ii++){
1882         a.Append(Form("%d",fCuts[ii]));
1883   }
1884   return a;
1885 }
1886
1887
1888 ///________________________________________________________________________
1889 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010PbPb(){
1890     //Create and return standard 2010 PbPb cuts
1891     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");
1892     if(!cuts->InitializeCutsFromCutString("9069640364102")){
1893         cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}
1894     return cuts;
1895 }
1896
1897 ///________________________________________________________________________
1898 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010pp(){
1899     //Create and return standard 2010 PbPb cuts
1900     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010pp","StandardCuts2010pp");
1901
1902     if(!cuts->InitializeCutsFromCutString("9069640364102")){
1903         cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}
1904      return cuts;
1905 }
1906