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         case 8: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kBoth);
1230                 break;
1231         case 9: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kBoth);
1232                 fesdTrackCuts->SetMinNClustersITS(4);
1233                 break;
1234
1235         default:
1236                 cout<<"Warning: clsITSCut not defined "<<clsITSCut<<endl;
1237                 return kFALSE;
1238         }
1239
1240 return kTRUE;
1241 }
1242
1243 ///________________________________________________________________________
1244 Bool_t AliDalitzElectronCuts::SetTPCClusterCut(Int_t clsTPCCut)
1245 {   // Set Cut
1246         switch(clsTPCCut){
1247         case 0: // 0
1248                 fMinClsTPC= 0.;
1249                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1250                 break;
1251         case 1:  // 70
1252                 fMinClsTPC= 70.;
1253                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1254                 break;
1255         case 2:  // 80
1256                 fMinClsTPC= 80.;
1257                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1258                 break;
1259         case 3:  // Changed 2014-02-04  before fMinClsTPC = 50.;
1260                 fMinClsTPCToF = 0.8;
1261                 fesdTrackCuts->SetMinNCrossedRowsTPC(70);
1262                 fesdTrackCuts->SetMinNClustersTPC(0);
1263                 fUseCrossedRows = kTRUE;
1264                 break;
1265         case 4:  // 0% of findable clusters
1266                 fMinClsTPC= 70.;
1267                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1268                 fMinClsTPCToF= 0.0;
1269                 fUseCorrectedTPCClsInfo=0;
1270                 break;
1271         case 5:  // 35% of findable clusters
1272                 fMinClsTPC = 70.;
1273                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1274                 fMinClsTPCToF= 0.35;
1275                 fUseCorrectedTPCClsInfo=0;
1276                 break;
1277         case 6:  // 60% of findable clusters
1278                 fMinClsTPC= 70.;
1279                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1280                 fMinClsTPCToF= 0.6;
1281                 fUseCorrectedTPCClsInfo=0;
1282                 break;
1283         case 7:  // 60% Changed 2014-02-04 before fMinClsTPC = 0.7 fUseCorrectedTPCClsInfo = 0
1284                  // Changed 2014-02-04  before fMinClsTPC = 50.;
1285                 fMinClsTPCToF = 0.6;
1286                 fesdTrackCuts->SetMinNCrossedRowsTPC(70);
1287                 fesdTrackCuts->SetMinNClustersTPC(0);
1288                 fUseCrossedRows = kTRUE;
1289                 break;
1290         case 8: fMinClsTPC = 0.;
1291                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1292                 fMinClsTPCToF= 0.35;
1293                 fUseCorrectedTPCClsInfo=0;
1294                 break;
1295         case 9:  // 35% of findable clusters
1296                 fMinClsTPC = 70.;
1297                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);
1298                 fMinClsTPCToF= 0.35;
1299                 fUseCorrectedTPCClsInfo=1;
1300                 break;
1301
1302         default:
1303                 cout<<"Warning: clsTPCCut not defined "<<clsTPCCut<<endl;
1304                 return kFALSE;
1305         }
1306         return kTRUE;
1307 }
1308
1309 ///________________________________________________________________________
1310 Bool_t AliDalitzElectronCuts::SetEtaCut(Int_t etaCut)
1311 {
1312   // Set eta Cut
1313         switch(etaCut){
1314         case 0:
1315                 fEtaCut = 100.;
1316                 fDoEtaCut = kFALSE;
1317                 break;
1318         case 1: // 1.4
1319                 fEtaCut = 1.4;
1320                 fDoEtaCut = kTRUE;
1321                 break;
1322         case 2: // 1.2
1323                 fEtaCut = 1.2;
1324                 fDoEtaCut = kTRUE;
1325                 break;
1326         case 3: // 0.9
1327                 fEtaCut = 0.9;
1328                 fDoEtaCut = kTRUE;
1329                 break;
1330         case 4: // 0.8
1331                 fEtaCut = 0.8;
1332                 fDoEtaCut = kTRUE;
1333                 break;
1334         case 5: // 0.75
1335                 fEtaCut = 0.75;
1336                 fDoEtaCut = kTRUE;
1337                 break;
1338         case 6: //0.6
1339                 fEtaCut = 0.6; //changed from 0.4 to 0.6 2013.06.10
1340                 fDoEtaCut = kTRUE;
1341                 break;
1342         case 7: //0.5
1343                 fEtaCut = 0.5; //changed from 0.3 to 0.5 2013.06.10
1344                 fDoEtaCut = kTRUE;
1345                 break;
1346         case 8: fEtaCut = 0.4;
1347                 fDoEtaCut = kTRUE;
1348                 break;
1349         case 9: fEtaCut = 0.65;
1350                 fDoEtaCut = kTRUE;
1351                 break;
1352         default:
1353                 cout<<"Warning: EtaCut not defined "<<etaCut<<endl;
1354                 return kFALSE;
1355         }
1356         return kTRUE;
1357 }
1358
1359 ///________________________________________________________________________
1360 Bool_t AliDalitzElectronCuts::SetPtCut(Int_t ptCut)
1361 {
1362         // Set Pt Cut
1363          //0.1GeV, 0.125 GeV, 0.15 GeV
1364
1365         switch(ptCut){
1366
1367         case 0: fPtMinCut = 0.075;
1368                 fPtMaxCut = 9999;
1369                 break;
1370         case 1:  // 0.1
1371                 fPtMinCut  = 0.1;
1372                 fPtMaxCut  = 9999;
1373                 break;
1374         case 2:  // 0.125 GeV
1375                 fPtMinCut = 0.125;
1376                 fPtMaxCut = 9999;
1377                 break;
1378         case 3: // 0.15 GeV
1379                 fPtMinCut = 0.15;
1380                 fPtMaxCut = 9999;
1381                 break;
1382                 // 0.5 - 0.7
1383         case 4: fPtMinCut = 0.5;
1384                 fPtMaxCut = 0.7;
1385                 break;
1386         case 5: // 0.175 GeV
1387                 fPtMinCut = 0.175;
1388                 fPtMaxCut = 9999;
1389                 break;
1390         default:
1391                 cout<<"Warning: PtCut not defined "<<ptCut<<endl;
1392                 return kFALSE;
1393         }
1394         return kTRUE;
1395 }
1396
1397
1398 ///________________________________________________________________________
1399 Bool_t AliDalitzElectronCuts::SetDCACut(Int_t dcaCut)
1400 {
1401   // Set DCA Cut
1402
1403         if( !fesdTrackCuts ) {
1404
1405                 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;
1406                 return kFALSE;
1407         }
1408
1409         switch(dcaCut){
1410
1411         case 0:
1412                 //Open cuts//
1413                 fesdTrackCuts->SetMaxDCAToVertexZ(1000);
1414                 fesdTrackCuts->SetMaxDCAToVertexXY(1000);
1415                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
1416                 break;
1417
1418         case 1:
1419                 fesdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
1420                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
1421
1422                 break;
1423         case 2: fesdTrackCuts->SetMaxDCAToVertexZ(2);
1424                 fesdTrackCuts->SetMaxDCAToVertexXY(1);
1425                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
1426                 break;
1427
1428         case 3: fesdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0105+0.0350/pt^1.1");
1429                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
1430                 break;
1431
1432         default:
1433                 cout<<"Warning: dcaCut not defined "<<dcaCut<<endl;
1434                 return kFALSE;
1435         }
1436         return kTRUE;
1437 }
1438
1439
1440
1441
1442 ///________________________________________________________________________
1443 Bool_t AliDalitzElectronCuts::SetMaxMomPiondEdxTPCCut(Int_t piMaxMomdedxSigmaCut)
1444 {   // Set Cut
1445    switch(piMaxMomdedxSigmaCut){
1446
1447          case 0:
1448                  fPIDMaxPnSigmaAbovePionLineTPC=0.;
1449                  break;
1450          case 1:  // 100. GeV
1451                  fPIDMaxPnSigmaAbovePionLineTPC=100.;
1452                  break;
1453          case 2:  // 5. GeV
1454                  fPIDMaxPnSigmaAbovePionLineTPC=5.;
1455                         break;
1456          case 3:  // 4. GeV
1457                  fPIDMaxPnSigmaAbovePionLineTPC=4.;
1458                  break;
1459          case 4:  // 3.5 GeV
1460                  fPIDMaxPnSigmaAbovePionLineTPC=3.5;
1461                  break;
1462          case 5:  // 3. GeV
1463                  fPIDMaxPnSigmaAbovePionLineTPC=3.;
1464                  break;
1465          default:
1466                  cout<<"Warning: piMaxMomdedxSigmaCut not defined "<<piMaxMomdedxSigmaCut<<endl;
1467                  return kFALSE;
1468          }
1469          return kTRUE;
1470 }
1471
1472 ///________________________________________________________________________
1473 Bool_t AliDalitzElectronCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)
1474 {   // Set Cut
1475         switch(LowPRejectionSigmaCut){
1476         case 0:  //
1477                 fDoKaonRejectionLowP=kFALSE;
1478                 fDoProtonRejectionLowP=kFALSE;
1479                 fDoPionRejectionLowP=kFALSE;
1480                 fPIDnSigmaAtLowPAroundKaonLine=0;
1481                 fPIDnSigmaAtLowPAroundProtonLine=0;
1482                 fPIDnSigmaAtLowPAroundPionLine=0;
1483                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1484                 break;
1485         case 1:  //
1486                 fDoKaonRejectionLowP=kTRUE;
1487                 fDoProtonRejectionLowP=kTRUE;
1488                 fDoPionRejectionLowP=kTRUE;
1489                 fPIDnSigmaAtLowPAroundKaonLine=0.5;
1490                 fPIDnSigmaAtLowPAroundProtonLine=0.5;
1491                 fPIDnSigmaAtLowPAroundPionLine=0.5;
1492                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1493                 break;
1494         case 2:  //
1495                 fDoKaonRejectionLowP=kTRUE;
1496                 fDoProtonRejectionLowP=kTRUE;
1497                 fDoPionRejectionLowP=kTRUE;
1498                 fPIDnSigmaAtLowPAroundKaonLine=1.0;
1499                 fPIDnSigmaAtLowPAroundProtonLine=1.0;
1500                 fPIDnSigmaAtLowPAroundPionLine=1.0;
1501                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1502                 break;
1503         case 3:  //
1504                 fDoKaonRejectionLowP=kTRUE;
1505                 fDoProtonRejectionLowP=kTRUE;
1506                 fDoPionRejectionLowP=kTRUE;
1507                 fPIDnSigmaAtLowPAroundKaonLine=1.5;
1508                 fPIDnSigmaAtLowPAroundProtonLine=1.5;
1509                 fPIDnSigmaAtLowPAroundPionLine=1.5;
1510                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1511                 break;
1512         case 4:  //
1513                 fDoKaonRejectionLowP=kTRUE;
1514                 fDoProtonRejectionLowP=kTRUE;
1515                 fDoPionRejectionLowP=kTRUE;
1516                 fPIDnSigmaAtLowPAroundKaonLine=2.0;
1517                 fPIDnSigmaAtLowPAroundProtonLine=2.0;
1518                 fPIDnSigmaAtLowPAroundPionLine=2.0;
1519                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1520                 break;
1521         case 5:  //
1522                 fDoKaonRejectionLowP=kTRUE;
1523                 fDoProtonRejectionLowP=kTRUE;
1524                 fDoPionRejectionLowP=kTRUE;
1525                 fPIDnSigmaAtLowPAroundKaonLine=2.0;
1526                 fPIDnSigmaAtLowPAroundProtonLine=2.0;
1527                 fPIDnSigmaAtLowPAroundPionLine=2.5;
1528                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1529                 break;
1530         case 6:  //
1531                 fDoKaonRejectionLowP=kTRUE;
1532                 fDoProtonRejectionLowP=kTRUE;
1533                 fDoPionRejectionLowP=kTRUE;
1534                 fPIDnSigmaAtLowPAroundKaonLine=0.;
1535                 fPIDnSigmaAtLowPAroundProtonLine=0.;
1536                 fPIDnSigmaAtLowPAroundPionLine=2.;
1537                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1538                 break;
1539         case 7: //
1540                 fDoKaonRejectionLowP=kFALSE;
1541                 fDoProtonRejectionLowP=kFALSE;
1542                 fDoPionRejectionLowP=kTRUE;
1543                 fPIDnSigmaAtLowPAroundKaonLine=0.0;
1544                 fPIDnSigmaAtLowPAroundProtonLine=0.0;
1545                 fPIDnSigmaAtLowPAroundPionLine=1.0;
1546                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1547                 break;
1548         case 8:
1549                 fDoKaonRejectionLowP=kFALSE;
1550                 fDoProtonRejectionLowP=kFALSE;
1551                 fDoPionRejectionLowP=kTRUE;
1552                 fPIDnSigmaAtLowPAroundKaonLine=0.;
1553                 fPIDnSigmaAtLowPAroundProtonLine=0.;
1554                 fPIDnSigmaAtLowPAroundPionLine=0.5;
1555                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;
1556                 break;
1557         default:
1558                 cout<<"Warning: LowPRejectionSigmaCut not defined "<<LowPRejectionSigmaCut<<endl;
1559                 return kFALSE;
1560         }
1561         return kTRUE;
1562 }
1563
1564 ///________________________________________________________________________
1565 Bool_t AliDalitzElectronCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){
1566     // Set Cut
1567         switch(TOFelectronPID){ // RRnewTOF start //////////////////////////////////////////////////////////////////////////
1568         case 0: // no cut
1569                 fRequireTOF = kFALSE;
1570                 fUseTOFpid = kFALSE;
1571                 fTofPIDnSigmaBelowElectronLine=-100;
1572                 fTofPIDnSigmaAboveElectronLine=100;
1573                 break;
1574         case 1: // -7,7
1575                 fRequireTOF = kFALSE;
1576                 fUseTOFpid = kTRUE;
1577                 fTofPIDnSigmaBelowElectronLine=-7;
1578                 fTofPIDnSigmaAboveElectronLine=7;
1579                 break;
1580         case 2: // -5,5
1581                 fRequireTOF = kFALSE;
1582                 fUseTOFpid = kTRUE;
1583                 fTofPIDnSigmaBelowElectronLine=-5;
1584                 fTofPIDnSigmaAboveElectronLine=5;
1585                 break;
1586         case 3: // -3,5
1587                 fRequireTOF = kFALSE;
1588                 fUseTOFpid = kTRUE;
1589                 fTofPIDnSigmaBelowElectronLine=-3;
1590                 fTofPIDnSigmaAboveElectronLine=5;
1591                 break;
1592         case 4: // -2,3
1593                 fRequireTOF = kFALSE;
1594                 fUseTOFpid = kTRUE;
1595                 fTofPIDnSigmaBelowElectronLine=-2;
1596                 fTofPIDnSigmaAboveElectronLine=3;
1597                 break;
1598         case 5: // -3, 3 TOF mandatory
1599                 fRequireTOF = kTRUE;
1600                 fUseTOFpid  = kTRUE;
1601                 fTofPIDnSigmaBelowElectronLine= -3;
1602                 fTofPIDnSigmaAboveElectronLine=  3;
1603                 break;
1604         default:
1605         cout<<"Warning: TOFElectronCut not defined "<<TOFelectronPID<<endl;
1606         return kFALSE;
1607     } //////////////////////// RRnewTOF end //////////////////////////////////////////////////////////////////////////
1608     return kTRUE;
1609 }
1610 ///_______________________________________________________________________________
1611
1612 Bool_t AliDalitzElectronCuts::SetPsiPairCut(Int_t psiCut) {
1613
1614
1615   switch(psiCut) {
1616   case 0:
1617         fDoPsiPairCut = kFALSE;
1618         fPsiPairCut = 10000.; //
1619         fDeltaPhiCutMin = -1000.;
1620         fDeltaPhiCutMax =  1000.;
1621
1622         break;
1623   case 1:
1624         fDoPsiPairCut = kTRUE;
1625         fPsiPairCut = 0.45; // Standard
1626         fDeltaPhiCutMin = 0.0;
1627         fDeltaPhiCutMax = 0.12;
1628         break;
1629   case 2:
1630         fDoPsiPairCut = kTRUE;
1631         fPsiPairCut = 0.60;
1632         fDeltaPhiCutMin = 0.0;
1633         fDeltaPhiCutMax = 0.12;
1634         break;
1635   case 3:
1636         fDoPsiPairCut = kTRUE;
1637         fPsiPairCut = 0.52;
1638         fDeltaPhiCutMin = 0.0;
1639         fDeltaPhiCutMax = 0.12;
1640         break;
1641   case 4:
1642         fDoPsiPairCut = kTRUE;
1643         fPsiPairCut = 0.30;
1644         fDeltaPhiCutMin = 0.0;
1645         fDeltaPhiCutMax = 0.12;
1646         break;
1647
1648   default:
1649       cout<<"Warning: PsiPairCut not defined "<<fPsiPairCut<<endl;
1650       return kFALSE;
1651   }
1652
1653   return kTRUE;
1654 }
1655
1656 ///_______________________________________________________________________________
1657 Bool_t AliDalitzElectronCuts::SetRejectSharedElecGamma(Int_t RCut) {
1658
1659
1660   switch(RCut) {
1661   case 0:
1662         fDoRejectSharedElecGamma = kFALSE;
1663         fRadiusCut = 10000; //
1664         break;
1665   case 1:
1666         fDoRejectSharedElecGamma = kTRUE;
1667         fRadiusCut = 2.0; // cm
1668         break;
1669   case 2:
1670         fDoRejectSharedElecGamma = kTRUE;
1671         fRadiusCut = 3.0; // Standard
1672         break;
1673   case 3:
1674         fDoRejectSharedElecGamma = kTRUE;
1675         fRadiusCut = 4.0; //
1676         break;
1677   case 4:
1678         fDoRejectSharedElecGamma = kTRUE;
1679         fRadiusCut = 5.0; //
1680         break;
1681   case 5:
1682         fDoRejectSharedElecGamma = kTRUE;
1683         fRadiusCut = 10.0; //
1684         break;
1685   case 6:
1686         fDoRejectSharedElecGamma = kTRUE;
1687         fRadiusCut = 15.0; //
1688         break;
1689   default:
1690       cout<<"Warning: PsiPairCut not defined "<<fDoRejectSharedElecGamma<<endl;
1691       return kFALSE;
1692   }
1693
1694   return kTRUE;
1695 }
1696 ///__________________________________________________________________________
1697 Bool_t AliDalitzElectronCuts::SetBackgroundScheme(Int_t BackgroundScheme){
1698
1699     // Set Cut
1700     switch(BackgroundScheme){
1701
1702     case 0: //Rotation
1703             fBKGMethod = 0;
1704             fUseTrackMultiplicityForBG = kFALSE;
1705         break;
1706     case 1: // mixed event with V0 multiplicity
1707             fBKGMethod  = 1;
1708             fUseTrackMultiplicityForBG = kFALSE;
1709         break;
1710     case 2: // mixed event with track multiplicity
1711             fUseTrackMultiplicityForBG = kTRUE;
1712             fBKGMethod  = 1;
1713         break;
1714     case 3: //Rotation
1715            fUseTrackMultiplicityForBG = kFALSE;
1716             fBKGMethod  = 2;
1717         break;
1718     case 4: //Rotation
1719             fUseTrackMultiplicityForBG = kTRUE;
1720             fBKGMethod  = 2;
1721         break;
1722     case 5: fUseTrackMultiplicityForBG = kTRUE;
1723             fBKGMethod  = 3;
1724         break;
1725
1726     default:
1727         cout<<"Warning: BackgroundScheme not defined "<<BackgroundScheme<<endl;
1728         return kFALSE;
1729     }
1730     return kTRUE;
1731 }
1732
1733 ///________________________________________________________________________
1734 Bool_t AliDalitzElectronCuts::SetNumberOfRotations(Int_t NumberOfRotations)
1735 {   // Set Cut
1736     switch(NumberOfRotations){
1737     case 0:
1738         fnumberOfRotationEventsForBG = 5;
1739         break;
1740     case 1:
1741         fnumberOfRotationEventsForBG = 10;
1742         break;
1743     case 2:
1744         fnumberOfRotationEventsForBG = 15;
1745         break;
1746     case 3:
1747         fnumberOfRotationEventsForBG = 20;
1748         break;
1749     case 4:
1750         fnumberOfRotationEventsForBG = 2;
1751         break;
1752     case 5:
1753         fnumberOfRotationEventsForBG = 50;
1754         break;
1755     case 6:
1756         fnumberOfRotationEventsForBG = 80;
1757         break;
1758     case 7:
1759         fnumberOfRotationEventsForBG = 100;
1760         break;
1761     default:
1762         cout<<"Warning: NumberOfRotations not defined "<<NumberOfRotations<<endl;
1763         return kFALSE;
1764     }
1765     return kTRUE;
1766 }
1767
1768
1769
1770 ///________________________________________________________________________
1771 Bool_t AliDalitzElectronCuts::SetDoWeights(Int_t opc)
1772 {   // Set Cut
1773     switch(opc){
1774
1775     case 0:             fDoWeights = kFALSE;
1776                         break;
1777     case 1:             fDoWeights = kTRUE;
1778                         break;
1779     default:
1780                         cout<<"Warning: Weights option not defined "<<opc<<endl;
1781                         return kFALSE;
1782     }
1783     return kTRUE;
1784 }
1785 ///________________________________________________________________________
1786 Bool_t AliDalitzElectronCuts::SetMassCut(Int_t massCut)
1787 {   // Set Cut
1788     switch(massCut){
1789
1790     case 0:
1791
1792                         fMassCutPtMin  = -999.; //GeV
1793                         fMassCutLowPt  =  999.; //GeV/c^2
1794                         fMassCutHighPt =  999.; //GeV/c^2
1795                         fMassMinCut = -999;
1796                         fDoMassCut = kFALSE;
1797                         fDoMassMinCut = kFALSE;
1798                         break;
1799     case 1:
1800                         //fMassCut = 0.135;             //GeV/c^2
1801                         fMassCutPtMin  = -999.; //GeV
1802                         fMassCutLowPt  = 0.135; //GeV/c^2
1803                         fMassCutHighPt = 0.135; //GeV/c^2
1804                         fMassMinCut = -999;
1805                         fDoMassCut = kTRUE;
1806                         fDoMassMinCut = kFALSE;
1807                         break;
1808     case 2:
1809                         //fMassCut = 0.100;     //GeV/c^2
1810                         fMassCutPtMin  = -999.; //GeV
1811                         fMassCutLowPt  = 0.100; //GeV/c^2
1812                         fMassCutHighPt = 0.100; //GeV/c^2
1813                         fMassMinCut = -999;
1814                         fDoMassCut = kTRUE;
1815                         fDoMassMinCut = kFALSE;
1816                         break;
1817     case 3:
1818                         /*fMassCut = 0.075;     //GeV/c^2 Changed from Feb 25
1819                         fMassCutPtMin  = -999.; //GeV
1820                         fMassCutLowPt  = 0.075; //GeV/c^2
1821                         fMassCutHighPt = 0.075; //GeV/c^2
1822                         fDoMassCut = kTRUE;
1823                         fDoMassMinCut = kFALSE;*/
1824                         fMassCutPtMin  = 1.0;   //GeV
1825                         fMassCutLowPt  = 0.015; //GeV/c^2
1826                         fMassCutHighPt = 0.035; //GeV/c^2
1827                         fMassMinCut    = 0.002;
1828                         fDoMassCut = kTRUE;
1829                         fDoMassMinCut = kTRUE;
1830                         break;
1831     case 4:
1832                         //fMassCut = 0.050;     //GeV/c^2
1833                         fMassCutPtMin  = -999.; //GeV
1834                         fMassCutLowPt  = 0.050; //GeV/c^2
1835                         fMassCutHighPt = 0.050; //GeV/c^2
1836                         fMassMinCut = -999;
1837                         fDoMassCut = kTRUE;
1838                         fDoMassMinCut = kFALSE;
1839                         break;
1840     case 5:
1841
1842                         fMassCutPtMin  = -999.; //GeV
1843                         fMassCutLowPt  = 0.035; //GeV/c^2
1844                         fMassCutHighPt = 0.035; //GeV/c^2
1845                         fMassMinCut = -999;
1846                         fDoMassCut = kTRUE;
1847                         fDoMassMinCut = kFALSE;
1848                         break;
1849     case 6:
1850                         fMassCutPtMin  = -999.; //GeV
1851                         fMassCutLowPt  = 0.015; //GeV/c^2
1852                         fMassCutHighPt = 0.015; //GeV/c^2
1853                         fMassMinCut = -999;
1854                         fDoMassCut = kTRUE;
1855                         fDoMassMinCut = kFALSE;
1856                         break;
1857     case 7:             fMassCutPtMin  = 1.0;   //GeV
1858                         fMassCutLowPt  = 0.015; //GeV/c^2
1859                         fMassCutHighPt = 0.035; //GeV/c^2
1860                         fMassMinCut = -999;
1861                         fDoMassCut = kTRUE;
1862                         fDoMassMinCut = kFALSE;
1863                         break;
1864     case 8:             fMassCutPtMin  = 1.0;   //GeV
1865                         fMassCutLowPt  = 0.015; //GeV/c^2
1866                         fMassCutHighPt = 0.050; //GeV/c^2
1867                         fMassMinCut = -999;
1868                         fDoMassCut = kTRUE;
1869                         fDoMassMinCut = kFALSE;
1870                         break;
1871     case 9:             fMassCutPtMin  = 1.0;   //GeV
1872                         fMassCutLowPt  = 0.025; //GeV/c^2
1873                         fMassCutHighPt = 0.035; //GeV/c^2
1874                         fMassMinCut = -999;
1875                         fDoMassCut = kTRUE;
1876                         fDoMassMinCut = kFALSE;
1877                         break;
1878     default:
1879                         cout<<"Warning: MassCut not defined "<<massCut<<endl;
1880                         return kFALSE;
1881     }
1882     return kTRUE;
1883 }
1884
1885
1886
1887 ///________________________________________________________________________
1888 TString AliDalitzElectronCuts::GetCutNumber(){
1889     // returns TString with current cut number
1890   TString a(kNCuts);
1891   for(Int_t ii=0;ii<kNCuts;ii++){
1892         a.Append(Form("%d",fCuts[ii]));
1893   }
1894   return a;
1895 }
1896
1897
1898 ///________________________________________________________________________
1899 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010PbPb(){
1900     //Create and return standard 2010 PbPb cuts
1901     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");
1902     if(!cuts->InitializeCutsFromCutString("9069640364102")){
1903         cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}
1904     return cuts;
1905 }
1906
1907 ///________________________________________________________________________
1908 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010pp(){
1909     //Create and return standard 2010 PbPb cuts
1910     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010pp","StandardCuts2010pp");
1911
1912     if(!cuts->InitializeCutsFromCutString("9069640364102")){
1913         cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}
1914      return cuts;
1915 }
1916