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