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